sig
module Std :
sig
module type Node =
sig
type t
type graph
type label
type edge
val create : Graphlib.Std.Node.label -> Graphlib.Std.Node.t
val label : Graphlib.Std.Node.t -> Graphlib.Std.Node.label
val mem : Graphlib.Std.Node.t -> Graphlib.Std.Node.graph -> bool
val succs :
Graphlib.Std.Node.t ->
Graphlib.Std.Node.graph -> Graphlib.Std.Node.t Regular.Std.seq
val preds :
Graphlib.Std.Node.t ->
Graphlib.Std.Node.graph -> Graphlib.Std.Node.t Regular.Std.seq
val inputs :
Graphlib.Std.Node.t ->
Graphlib.Std.Node.graph -> Graphlib.Std.Node.edge Regular.Std.seq
val outputs :
Graphlib.Std.Node.t ->
Graphlib.Std.Node.graph -> Graphlib.Std.Node.edge Regular.Std.seq
val degree :
?dir:[ `In | `Out ] ->
Graphlib.Std.Node.t -> Graphlib.Std.Node.graph -> int
val insert :
Graphlib.Std.Node.t ->
Graphlib.Std.Node.graph -> Graphlib.Std.Node.graph
val update :
Graphlib.Std.Node.t ->
Graphlib.Std.Node.label ->
Graphlib.Std.Node.graph -> Graphlib.Std.Node.graph
val remove :
Graphlib.Std.Node.t ->
Graphlib.Std.Node.graph -> Graphlib.Std.Node.graph
val has_edge :
Graphlib.Std.Node.t ->
Graphlib.Std.Node.t -> Graphlib.Std.Node.graph -> bool
val edge :
Graphlib.Std.Node.t ->
Graphlib.Std.Node.t ->
Graphlib.Std.Node.graph -> Graphlib.Std.Node.edge option
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module type Edge =
sig
type t
type node
type graph
type label
val create :
Graphlib.Std.Edge.node ->
Graphlib.Std.Edge.node ->
Graphlib.Std.Edge.label -> Graphlib.Std.Edge.t
val label : Graphlib.Std.Edge.t -> Graphlib.Std.Edge.label
val src : Graphlib.Std.Edge.t -> Graphlib.Std.Edge.node
val dst : Graphlib.Std.Edge.t -> Graphlib.Std.Edge.node
val mem : Graphlib.Std.Edge.t -> Graphlib.Std.Edge.graph -> bool
val insert :
Graphlib.Std.Edge.t ->
Graphlib.Std.Edge.graph -> Graphlib.Std.Edge.graph
val update :
Graphlib.Std.Edge.t ->
Graphlib.Std.Edge.label ->
Graphlib.Std.Edge.graph -> Graphlib.Std.Edge.graph
val remove :
Graphlib.Std.Edge.t ->
Graphlib.Std.Edge.graph -> Graphlib.Std.Edge.graph
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module type Graph =
sig
type t
type node
type edge
module Node :
sig
type t = node
type graph = t
type label
type edge = edge
val create : label -> t
val label : t -> label
val mem : t -> graph -> bool
val succs : t -> graph -> t Regular.Std.seq
val preds : t -> graph -> t Regular.Std.seq
val inputs : t -> graph -> edge Regular.Std.seq
val outputs : t -> graph -> edge Regular.Std.seq
val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
val insert : t -> graph -> graph
val update : t -> label -> graph -> graph
val remove : t -> graph -> graph
val has_edge : t -> t -> graph -> bool
val edge : t -> t -> graph -> edge option
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = node
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(node, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : node -> 'a -> 'a t
val of_alist :
(node * 'a) list ->
[ `Duplicate_key of node | `Ok of 'a t ]
val of_alist_or_error :
(node * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (node * 'a) list -> 'a t
val of_alist_multi : (node * 'a) list -> 'a list t
val of_alist_fold :
(node * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(node * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(node * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of node | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:node -> data:'a -> 'a t
val add_multi :
'a list t -> key:node -> data:'a -> 'a list t
val remove_multi : 'a list t -> node -> 'a list t
val change :
'a t -> node -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> node -> f:('a option -> 'a) -> 'a t
val find : 'a t -> node -> 'a option
val find_exn : 'a t -> node -> 'a
val remove : 'a t -> node -> 'a t
val mem : 'a t -> node -> bool
val iter_keys : 'a t -> f:(node -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:node -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(node -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:node -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:node -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:node -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:node -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> node list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (node * 'a) list
val validate :
name:(node -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:node ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(node, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (node * 'a) option
val min_elt_exn : 'a t -> node * 'a
val max_elt : 'a t -> (node * 'a) option
val max_elt_exn : 'a t -> node * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:node -> data:'a -> bool) -> int
val split :
'a t -> node -> 'a t * (node * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:node Base__.Maybe_bound.t ->
upper_bound:node Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:node ->
max:node ->
init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:node -> max:node -> (node * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> node -> (node * 'a) option
val nth : 'a t -> int -> (node * 'a) option
val nth_exn : 'a t -> int -> node * 'a
val rank : 'a t -> node -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:node ->
?keys_less_or_equal_to:node ->
'a t -> (node * 'a) Base__.Sequence.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> node end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(node, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : node -> 'a -> 'a t
val of_alist :
(node * 'a) list ->
[ `Duplicate_key of node | `Ok of 'a t ]
val of_alist_or_error :
(node * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (node * 'a) list -> 'a t
val of_alist_multi : (node * 'a) list -> 'a list t
val of_alist_fold :
(node * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(node * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (node * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of node | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:node -> data:'a -> 'a t
val add_multi :
'a list t -> key:node -> data:'a -> 'a list t
val remove_multi : 'a list t -> node -> 'a list t
val change :
'a t -> node -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> node -> f:('a option -> 'a) -> 'a t
val find : 'a t -> node -> 'a option
val find_exn : 'a t -> node -> 'a
val remove : 'a t -> node -> 'a t
val mem : 'a t -> node -> bool
val iter_keys : 'a t -> f:(node -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:node -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:node ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:node ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(node -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:node -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:node -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:node -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:node -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> node list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (node * 'a) list
val validate :
name:(node -> string) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:node ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(node, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (node * 'a) option
val min_elt_exn : 'a t -> node * 'a
val max_elt : 'a t -> (node * 'a) option
val max_elt_exn : 'a t -> node * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:node -> data:'a -> bool) -> int
val split :
'a t -> node -> 'a t * (node * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:node Base__.Maybe_bound.t ->
upper_bound:node Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:node ->
max:node ->
init:'b -> f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:node -> max:node -> (node * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> node -> (node * 'a) option
val nth : 'a t -> int -> (node * 'a) option
val nth_exn : 'a t -> int -> node * 'a
val rank : 'a t -> node -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:node ->
?keys_less_or_equal_to:node ->
'a t -> (node * 'a) Base__.Sequence.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> node end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : node Bin_prot.Type_class.t
val bin_read_t : node Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> node)
Bin_prot.Read.reader
val bin_reader_t :
node Bin_prot.Type_class.reader
val bin_size_t : node Bin_prot.Size.sizer
val bin_write_t : node Bin_prot.Write.writer
val bin_writer_t :
node Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
node -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = node
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(node, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(node -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> node -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(node -> bool) -> bool
val for_all : t -> f:(node -> bool) -> bool
val count : t -> f:(node -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(node -> 'sum) -> 'sum
val find : t -> f:(node -> bool) -> node option
val find_map : t -> f:(node -> 'a option) -> 'a option
val to_list : t -> node list
val to_array : t -> node array
val invariants : t -> bool
val mem : t -> node -> bool
val add : t -> node -> t
val remove : t -> node -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (node, node) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
node ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of node * node
| `Left of node
| `Right of node ] -> unit) ->
unit
val filter : t -> f:(node -> bool) -> t
val partition_tf : t -> f:(node -> bool) -> t * t
val elements : t -> node list
val min_elt : t -> node option
val min_elt_exn : t -> node
val max_elt : t -> node option
val max_elt_exn : t -> node
val choose : t -> node option
val choose_exn : t -> node
val split : t -> node -> t * node option * t
val group_by :
t -> equiv:(node -> node -> bool) -> t list
val find_exn : t -> f:(node -> bool) -> node
val find_index : t -> int -> node option
val nth : t -> int -> node option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node -> t -> node Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t ->
t ->
(node, node)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(node -> 'data) ->
(node, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : node -> t
val union_list : t list -> t
val of_list : node list -> t
val of_array : node array -> t
val of_sorted_array : node array -> t Base__.Or_error.t
val of_sorted_array_unchecked : node array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node) -> t
val stable_dedup_list : node list -> node list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> node) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> node option) -> t
val of_tree : t -> t
val of_hash_set : node Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(node, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(node, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (node, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(node -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> node -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(node -> bool) -> bool
val for_all : t -> f:(node -> bool) -> bool
val count : t -> f:(node -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(node -> 'sum) -> 'sum
val find : t -> f:(node -> bool) -> node option
val find_map : t -> f:(node -> 'a option) -> 'a option
val to_list : t -> node list
val to_array : t -> node array
val invariants : t -> bool
val mem : t -> node -> bool
val add : t -> node -> t
val remove : t -> node -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (node, node) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
node ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of node * node
| `Left of node
| `Right of node ] -> unit) ->
unit
val filter : t -> f:(node -> bool) -> t
val partition_tf : t -> f:(node -> bool) -> t * t
val elements : t -> node list
val min_elt : t -> node option
val min_elt_exn : t -> node
val max_elt : t -> node option
val max_elt_exn : t -> node
val choose : t -> node option
val choose_exn : t -> node
val split : t -> node -> t * node option * t
val group_by : t -> equiv:(node -> node -> bool) -> t list
val find_exn : t -> f:(node -> bool) -> node
val find_index : t -> int -> node option
val nth : t -> int -> node option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node -> t -> node Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t ->
t ->
(node, node)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(node -> 'data) ->
(node, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : node -> t
val union_list : t list -> t
val of_list : node list -> t
val of_array : node array -> t
val of_sorted_array : node array -> t Base__.Or_error.t
val of_sorted_array_unchecked : node array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node) -> t
val stable_dedup_list : node list -> node list
val map : ('a, 'b) Base.Set.t -> f:('a -> node) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> node option) -> t
val of_tree : Tree.t -> t
val of_hash_set : node Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(node, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(node, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> node end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : node Bin_prot.Type_class.t
val bin_read_t : node Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> node)
Bin_prot.Read.reader
val bin_reader_t :
node Bin_prot.Type_class.reader
val bin_size_t : node Bin_prot.Size.sizer
val bin_write_t : node Bin_prot.Write.writer
val bin_writer_t :
node Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
node -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = node
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> node -> Core_kernel__.Import.bool
val lookup : 'a t -> node -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> node -> 'a
val enqueue :
'a t -> node -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> node -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> node -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> node -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (node * 'a) Core_kernel__.Import.option
val keys : 'a t -> node Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (node * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> node * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> node -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> node -> Core_kernel__.Import.unit
val replace : 'a t -> node -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> node -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:node -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:node -> data:'a -> 'b) -> 'b
end
end
module Edge :
sig
type t = edge
type node = Node.t
type graph = Node.graph
type label
val create : node -> node -> label -> t
val label : t -> label
val src : t -> node
val dst : t -> node
val mem : t -> graph -> bool
val insert : t -> graph -> graph
val update : t -> label -> graph -> graph
val remove : t -> graph -> graph
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi : (edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t -> edge -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t -> edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> edge end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi : (edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t -> edge -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> string) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t -> edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b -> f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> edge end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t : edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t : edge Bin_prot.Size.sizer
val bin_write_t : edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(edge, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map : t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by :
t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array : edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge option) -> t
val of_tree : t -> t
val of_hash_set : edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (edge, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map : t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by : t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array : edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map : ('a, 'b) Base.Set.t -> f:('a -> edge) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> edge option) -> t
val of_tree : Tree.t -> t
val of_hash_set : edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> edge end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t : edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t : edge Bin_prot.Size.sizer
val bin_write_t : edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = edge
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> edge -> Core_kernel__.Import.bool
val lookup : 'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> edge -> 'a
val enqueue :
'a t -> edge -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val keys : 'a t -> edge Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> edge * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> edge -> Core_kernel__.Import.unit
val replace : 'a t -> edge -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:edge -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:edge -> data:'a -> 'b) -> 'b
end
end
val empty : Graphlib.Std.Graph.t
val nodes :
Graphlib.Std.Graph.t -> Graphlib.Std.Graph.node Regular.Std.seq
val edges :
Graphlib.Std.Graph.t -> Graphlib.Std.Graph.edge Regular.Std.seq
val is_directed : bool
val number_of_edges : Graphlib.Std.Graph.t -> int
val number_of_nodes : Graphlib.Std.Graph.t -> int
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = Edge.graph
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = Edge.graph
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq :
Format.formatter -> t Core_kernel.Std.Sequence.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
end
type ('c, 'n, 'e) graph =
(module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c)
type edge_kind = [ `Back | `Cross | `Forward | `Tree ]
type 'a tree
type 'a frontier
type 'a partition
type 'a group
type 'a path
type equiv
module Tree :
sig
type 'a t = 'a Graphlib.Std.tree
val children : 'a Graphlib.Std.Tree.t -> 'a -> 'a Regular.Std.seq
val parent : 'a Graphlib.Std.Tree.t -> 'a -> 'a option
val ancestors : 'a Graphlib.Std.Tree.t -> 'a -> 'a Regular.Std.seq
val descendants :
'a Graphlib.Std.Tree.t -> 'a -> 'a Regular.Std.seq
val is_child_of : 'a Graphlib.Std.Tree.t -> parent:'a -> 'a -> bool
val is_ancestor_of :
'a Graphlib.Std.Tree.t -> child:'a -> 'a -> bool
val is_descendant_of :
'a Graphlib.Std.Tree.t -> parent:'a -> 'a -> bool
val to_sequence : 'a Graphlib.Std.Tree.t -> 'a Regular.Std.seq
val pp :
'a Regular.Std.printer ->
'a Graphlib.Std.Tree.t Regular.Std.printer
end
module Frontier :
sig
type 'a t = 'a Graphlib.Std.frontier
val enum : 'a Graphlib.Std.Frontier.t -> 'a -> 'a Regular.Std.seq
val mem : 'a Graphlib.Std.Frontier.t -> 'a -> 'a -> bool
val to_sequence : 'a Graphlib.Std.Frontier.t -> 'a Regular.Std.seq
val pp :
'a Regular.Std.printer ->
'a Graphlib.Std.Frontier.t Regular.Std.printer
end
module Path :
sig
type 'e t = 'e Graphlib.Std.path
val start : 'e Graphlib.Std.Path.t -> 'e
val finish : 'e Graphlib.Std.Path.t -> 'e
val edges : 'e Graphlib.Std.Path.t -> 'e Regular.Std.seq
val edges_rev : 'e Graphlib.Std.Path.t -> 'e Regular.Std.seq
val weight : 'e Graphlib.Std.Path.t -> int
val length : 'e Graphlib.Std.Path.t -> int
val pp :
'a Regular.Std.printer ->
'a Graphlib.Std.Path.t Regular.Std.printer
end
module Partition :
sig
type 'a t = 'a Graphlib.Std.partition
val groups :
'a Graphlib.Std.Partition.t ->
'a Graphlib.Std.group Regular.Std.seq
val group :
'a Graphlib.Std.Partition.t -> 'a -> 'a Graphlib.Std.group option
val equiv : 'a Graphlib.Std.Partition.t -> 'a -> 'a -> bool
val number_of_groups : 'a Graphlib.Std.Partition.t -> int
val of_equiv :
'a Graphlib.Std.Partition.t ->
Graphlib.Std.equiv -> 'a Graphlib.Std.group option
val pp :
'a Regular.Std.printer ->
'a Graphlib.Std.Partition.t Regular.Std.printer
end
module Group :
sig
type 'a t = 'a Graphlib.Std.group
val enum : 'a Graphlib.Std.group -> 'a Regular.Std.seq
val mem : 'a Graphlib.Std.group -> 'a -> bool
val top : 'a Graphlib.Std.group -> 'a
val to_equiv : 'a Graphlib.Std.group -> Graphlib.Std.equiv
val pp :
'a Regular.Std.printer ->
'a Graphlib.Std.Group.t Regular.Std.printer
end
module Equiv :
sig
type t = Graphlib.Std.equiv
val to_int : Graphlib.Std.Equiv.t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq :
Format.formatter -> t Core_kernel.Std.Sequence.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
val comparator :
(t, comparator_witness) Core_kernel__.Comparator.comparator
module Map :
sig
module Key :
sig
type t = Graphlib.Std.equiv
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t -> f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi : 'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti : 'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t : Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state -> Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = Map.Key.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t : Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state -> Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
val hash : t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) -> 'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t -> init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri : 'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli : 'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti : 'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add : 'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change : 'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri : 'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key -> if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace : 'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli : 'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all : 'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t : key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t : key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t : elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t : elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup : 'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
type info = string * [ `Ver of string ] * string option
val version : string
val size_in_bytes : ?ver:string -> ?fmt:string -> t -> int
val of_bytes : ?ver:string -> ?fmt:string -> Regular.Std.bytes -> t
val to_bytes : ?ver:string -> ?fmt:string -> t -> Regular.Std.bytes
val blit_to_bytes :
?ver:string ->
?fmt:string -> Regular.Std.bytes -> t -> int -> unit
val of_bigstring :
?ver:string -> ?fmt:string -> Core_kernel.Std.bigstring -> t
val to_bigstring :
?ver:string -> ?fmt:string -> t -> Core_kernel.Std.bigstring
val blit_to_bigstring :
?ver:string ->
?fmt:string -> Core_kernel.Std.bigstring -> t -> int -> unit
module Io :
sig
val read : ?ver:string -> ?fmt:string -> string -> t
val load :
?ver:string ->
?fmt:string -> Core_kernel.Std.In_channel.t -> t
val load_all :
?ver:string ->
?fmt:string ->
?rev:bool -> Core_kernel.Std.In_channel.t -> t list
val scan :
?ver:string ->
?fmt:string ->
Core_kernel.Std.In_channel.t -> unit -> t option
val write : ?ver:string -> ?fmt:string -> string -> t -> unit
val save :
?ver:string ->
?fmt:string -> Core_kernel.Std.Out_channel.t -> t -> unit
val save_all :
?ver:string ->
?fmt:string ->
Core_kernel.Std.Out_channel.t -> t list -> unit
val dump :
?ver:string ->
?fmt:string ->
Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
val show : ?ver:string -> ?fmt:string -> t -> unit
val print :
?ver:string -> ?fmt:string -> Format.formatter -> t -> unit
end
module Cache :
sig
val load : Regular.Std.digest -> t option
val save : Regular.Std.digest -> t -> unit
end
val add_reader :
?desc:string ->
ver:string -> string -> t Regular.Std.reader -> unit
val add_writer :
?desc:string ->
ver:string -> string -> t Regular.Std.writer -> unit
val available_readers : unit -> info list
val default_reader : unit -> info
val set_default_reader : ?ver:string -> string -> unit
val with_reader : ?ver:string -> string -> (unit -> 'a) -> 'a
val available_writers : unit -> info list
val default_writer : unit -> info
val set_default_writer : ?ver:string -> string -> unit
val with_writer : ?ver:string -> string -> (unit -> 'a) -> 'a
val default_printer : unit -> info option
val set_default_printer : ?ver:string -> string -> unit
val with_printer : ?ver:string -> string -> (unit -> 'a) -> 'a
val find_reader :
?ver:string -> string -> t Regular.Std.reader option
val find_writer :
?ver:string -> string -> t Regular.Std.writer option
end
module type Predicate =
sig
type edge
type node
val edge : Graphlib.Std.Predicate.edge -> bool
val node : Graphlib.Std.Predicate.node -> bool
end
module type Isomorphism =
sig
type s
type t
val forward :
Graphlib.Std.Isomorphism.s -> Graphlib.Std.Isomorphism.t
val backward :
Graphlib.Std.Isomorphism.t -> Graphlib.Std.Isomorphism.s
end
class type ['n, 'e, 's] dfs_visitor =
object
method enter_edge : Graphlib.Std.edge_kind -> 'e -> 's -> 's
method enter_node : int -> 'n -> 's -> 's
method leave_edge : Graphlib.Std.edge_kind -> 'e -> 's -> 's
method leave_node : int -> 'n -> 's -> 's
method start_tree : 'n -> 's -> 's
end
type node_attr = Graph.Graphviz.DotAttributes.vertex
type edge_attr = Graph.Graphviz.DotAttributes.edge
type graph_attr = Graph.Graphviz.DotAttributes.graph
type ('n, 'a) labeled = { node : 'n; node_label : 'a; }
module Solution :
sig
type ('n, 'd) t
val create :
('n, 'd, 'a) Core_kernel.Std.Map.t ->
'd -> ('n, 'd) Graphlib.Std.Solution.t
val iterations : ('n, 'd) Graphlib.Std.Solution.t -> int
val default : ('n, 'd) Graphlib.Std.Solution.t -> 'd
val is_fixpoint : ('n, 'd) Graphlib.Std.Solution.t -> bool
val get : ('n, 'd) Graphlib.Std.Solution.t -> 'n -> 'd
val derive :
('n, 'd) Graphlib.Std.Solution.t ->
f:('n -> 'd -> 'a option) ->
'a -> ('n, 'a) Graphlib.Std.Solution.t
end
module Graphlib :
sig
module Make :
functor
(Node : Regular.Std.Opaque.S) (Edge : Core_kernel.Std.T) ->
sig
type t
type node = Node.t
type edge
module Node :
sig
type t = node
type graph = t
type label = t
type edge = edge
val create : label -> label
val label : label -> label
val mem : label -> graph -> bool
val succs : label -> graph -> label Regular.Std.seq
val preds : label -> graph -> label Regular.Std.seq
val inputs : label -> graph -> edge Regular.Std.seq
val outputs : label -> graph -> edge Regular.Std.seq
val degree : ?dir:[ `In | `Out ] -> label -> graph -> int
val insert : label -> graph -> graph
val update : label -> label -> graph -> graph
val remove : label -> graph -> graph
val has_edge : label -> label -> graph -> bool
val edge : label -> label -> graph -> edge option
val ( >= ) : label -> label -> bool
val ( <= ) : label -> label -> bool
val ( = ) : label -> label -> bool
val ( > ) : label -> label -> bool
val ( < ) : label -> label -> bool
val ( <> ) : label -> label -> bool
val equal : label -> label -> bool
val min : label -> label -> label
val max : label -> label -> label
val ascending : label -> label -> int
val descending : label -> label -> int
val between : label -> low:label -> high:label -> bool
val clamp_exn : label -> min:label -> max:label -> label
val clamp :
label ->
min:label -> max:label -> label Base__.Or_error.t
type comparator_witness
val comparator :
(label, comparator_witness)
Base__.Comparator.comparator
val validate_lbound :
min:label Base__.Maybe_bound.t ->
label Base__.Validate.check
val validate_ubound :
max:label Base__.Maybe_bound.t ->
label Base__.Validate.check
val validate_bound :
min:label Base__.Maybe_bound.t ->
max:label Base__.Maybe_bound.t ->
label Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : label -> label -> bool
val ( <= ) : label -> label -> bool
val ( = ) : label -> label -> bool
val ( > ) : label -> label -> bool
val ( < ) : label -> label -> bool
val ( <> ) : label -> label -> bool
val equal : label -> label -> bool
val compare : label -> label -> int
val min : label -> label -> label
val max : label -> label -> label
end
module Map :
sig
module Key :
sig
type t = label
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(label, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : label -> 'a -> 'a t
val of_alist :
(label * 'a) list ->
[ `Duplicate_key of label | `Ok of 'a t ]
val of_alist_or_error :
(label * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (label * 'a) list -> 'a t
val of_alist_multi :
(label * 'a) list -> 'a list t
val of_alist_fold :
(label * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(label * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(label * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(label * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> label * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:label -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of label | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(label, 'a) Core_kernel__.Core_hashtbl.t ->
'a t
val gen :
label Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:label -> data:'a -> 'a t
val add_multi :
'a list t -> key:label -> data:'a -> 'a list t
val remove_multi :
'a list t -> label -> 'a list t
val change :
'a t ->
label -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> label -> f:('a option -> 'a) -> 'a t
val find : 'a t -> label -> 'a option
val find_exn : 'a t -> label -> 'a
val remove : 'a t -> label -> 'a t
val mem : 'a t -> label -> bool
val iter_keys : 'a t -> f:(label -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t ->
f:(key:label -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:label ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:label -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:label -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:label -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:label ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys :
'a t -> f:(label -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t ->
f:(key:label -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:label -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:label ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:label -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> label list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (label * 'a) list
val validate :
name:(label -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:label ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(label, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (label * 'a) option
val min_elt_exn : 'a t -> label * 'a
val max_elt : 'a t -> (label * 'a) option
val max_elt_exn : 'a t -> label * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t ->
f:(key:label -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t ->
f:(key:label -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:label -> data:'a -> bool) -> int
val split :
'a t ->
label -> 'a t * (label * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:label Base__.Maybe_bound.t ->
upper_bound:label Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:label ->
max:label ->
init:'b ->
f:(key:label -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t ->
min:label -> max:label -> (label * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> label -> (label * 'a) option
val nth : 'a t -> int -> (label * 'a) option
val nth_exn : 'a t -> int -> label * 'a
val rank : 'a t -> label -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:label ->
?keys_less_or_equal_to:label ->
'a t -> (label * 'a) Base__.Sequence.t
val obs :
label Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
label Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp :
Sexplib.Sexp.t -> label
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(label, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : label -> 'a -> 'a t
val of_alist :
(label * 'a) list ->
[ `Duplicate_key of label | `Ok of 'a t ]
val of_alist_or_error :
(label * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (label * 'a) list -> 'a t
val of_alist_multi : (label * 'a) list -> 'a list t
val of_alist_fold :
(label * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(label * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(label * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(label * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> label * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:label -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of label | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(label, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
label Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:label -> data:'a -> 'a t
val add_multi :
'a list t -> key:label -> data:'a -> 'a list t
val remove_multi : 'a list t -> label -> 'a list t
val change :
'a t -> label -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> label -> f:('a option -> 'a) -> 'a t
val find : 'a t -> label -> 'a option
val find_exn : 'a t -> label -> 'a
val remove : 'a t -> label -> 'a t
val mem : 'a t -> label -> bool
val iter_keys : 'a t -> f:(label -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:label -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:label ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:label -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:label -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:label -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:label ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(label -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:label -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:label -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:label ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:label -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> label list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (label * 'a) list
val validate :
name:(label -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:label ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(label, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (label * 'a) option
val min_elt_exn : 'a t -> label * 'a
val max_elt : 'a t -> (label * 'a) option
val max_elt_exn : 'a t -> label * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:label -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:label -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:label -> data:'a -> bool) -> int
val split :
'a t -> label -> 'a t * (label * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:label Base__.Maybe_bound.t ->
upper_bound:label Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:label ->
max:label ->
init:'b ->
f:(key:label -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:label -> max:label -> (label * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> label -> (label * 'a) option
val nth : 'a t -> int -> (label * 'a) option
val nth_exn : 'a t -> int -> label * 'a
val rank : 'a t -> label -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:label ->
?keys_less_or_equal_to:label ->
'a t -> (label * 'a) Base__.Sequence.t
val obs :
label Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
label Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> label
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : label Bin_prot.Type_class.t
val bin_read_t :
label Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> label)
Bin_prot.Read.reader
val bin_reader_t :
label Bin_prot.Type_class.reader
val bin_size_t :
label Bin_prot.Size.sizer
val bin_write_t :
label Bin_prot.Write.writer
val bin_writer_t :
label Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t :
('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t :
('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
label -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = label
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(label, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(label -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> label -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum ->
label -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(label -> bool) -> bool
val for_all : t -> f:(label -> bool) -> bool
val count : t -> f:(label -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(label -> 'sum) -> 'sum
val find : t -> f:(label -> bool) -> label option
val find_map :
t -> f:(label -> 'a option) -> 'a option
val to_list : t -> label list
val to_array : t -> label array
val invariants : t -> bool
val mem : t -> label -> bool
val add : t -> label -> t
val remove : t -> label -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(label, label) Base__.Either.t
Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
label ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(label -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of label * label
| `Left of label
| `Right of label ] -> unit) ->
unit
val filter : t -> f:(label -> bool) -> t
val partition_tf :
t -> f:(label -> bool) -> t * t
val elements : t -> label list
val min_elt : t -> label option
val min_elt_exn : t -> label
val max_elt : t -> label option
val max_elt_exn : t -> label
val choose : t -> label option
val choose_exn : t -> label
val split : t -> label -> t * label option * t
val group_by :
t -> equiv:(label -> label -> bool) -> t list
val find_exn : t -> f:(label -> bool) -> label
val find_index : t -> int -> label option
val nth : t -> int -> label option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:label ->
?less_or_equal_to:label ->
t -> label Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:label ->
?less_or_equal_to:label ->
t ->
t ->
(label, label)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(label -> 'data) ->
(label, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
label Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
label Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : label -> t
val union_list : t list -> t
val of_list : label list -> t
val of_array : label array -> t
val of_sorted_array :
label array -> t Base__.Or_error.t
val of_sorted_array_unchecked : label array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> label) -> t
val stable_dedup_list : label list -> label list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> label) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> label option) -> t
val of_tree : t -> t
val of_hash_set :
label Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(label, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(label, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
label Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp :
Sexplib.Sexp.t -> label
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (label, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(label -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> label -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> label -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(label -> bool) -> bool
val for_all : t -> f:(label -> bool) -> bool
val count : t -> f:(label -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(label -> 'sum) -> 'sum
val find : t -> f:(label -> bool) -> label option
val find_map :
t -> f:(label -> 'a option) -> 'a option
val to_list : t -> label list
val to_array : t -> label array
val invariants : t -> bool
val mem : t -> label -> bool
val add : t -> label -> t
val remove : t -> label -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(label, label) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
label ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(label -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of label * label
| `Left of label
| `Right of label ] -> unit) ->
unit
val filter : t -> f:(label -> bool) -> t
val partition_tf : t -> f:(label -> bool) -> t * t
val elements : t -> label list
val min_elt : t -> label option
val min_elt_exn : t -> label
val max_elt : t -> label option
val max_elt_exn : t -> label
val choose : t -> label option
val choose_exn : t -> label
val split : t -> label -> t * label option * t
val group_by :
t -> equiv:(label -> label -> bool) -> t list
val find_exn : t -> f:(label -> bool) -> label
val find_index : t -> int -> label option
val nth : t -> int -> label option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:label ->
?less_or_equal_to:label ->
t -> label Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:label ->
?less_or_equal_to:label ->
t ->
t ->
(label, label)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(label -> 'data) ->
(label, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
label Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
label Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : label -> t
val union_list : t list -> t
val of_list : label list -> t
val of_array : label array -> t
val of_sorted_array :
label array -> t Base__.Or_error.t
val of_sorted_array_unchecked : label array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> label) -> t
val stable_dedup_list : label list -> label list
val map : ('a, 'b) Base.Set.t -> f:('a -> label) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> label option) -> t
val of_tree : Tree.t -> t
val of_hash_set : label Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(label, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(label, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
label Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> label
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : label Bin_prot.Type_class.t
val bin_read_t :
label Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> label)
Bin_prot.Read.reader
val bin_reader_t :
label Bin_prot.Type_class.reader
val bin_size_t :
label Bin_prot.Size.sizer
val bin_write_t :
label Bin_prot.Write.writer
val bin_writer_t :
label Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
label -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash :
t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : label -> Core_kernel__.Import.int
val compare : label -> label -> Core_kernel__.Import.int
val hashable :
label Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = label
type ('a, 'b) hashtbl = ('a, 'b) Equiv.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b,
(key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t ->
key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update :
'b t -> key -> f:('b option -> 'b) -> unit
val add_multi :
'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi :
'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t ->
f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) ->
if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key ->
'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal :
'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t :
key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = label
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig
val t_of_sexp : Sexplib.Sexp.t -> elt
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t :
elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = label
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map :
'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> label -> Core_kernel__.Import.bool
val lookup :
'a t -> label -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> label -> 'a
val enqueue :
'a t ->
label -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> label -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> label -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> label -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (label * 'a) Core_kernel__.Import.option
val keys : 'a t -> label Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (label * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> label * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> label -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> label -> Core_kernel__.Import.unit
val replace :
'a t -> label -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> label -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:label ->
data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b ->
f:('b -> key:label -> data:'a -> 'b) -> 'b
end
end
module Edge :
sig
type t = edge
type node = Node.t
type graph = Node.graph
type label = Edge.t
val create : node -> node -> label -> t
val label : t -> label
val src : t -> node
val dst : t -> node
val mem : t -> graph -> bool
val insert : t -> graph -> graph
val update : t -> label -> graph -> graph
val remove : t -> graph -> graph
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi :
(edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t ->
edge -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys :
'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t ->
edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t ->
min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi : (edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t -> edge -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t -> edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t :
edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t :
edge Bin_prot.Size.sizer
val bin_write_t :
edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t :
('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t :
('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(edge, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum ->
edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map :
t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by :
t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array :
edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge option) -> t
val of_tree : t -> t
val of_hash_set :
edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp :
Sexplib.Sexp.t -> edge
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (edge, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map :
t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by :
t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array :
edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map : ('a, 'b) Base.Set.t -> f:('a -> edge) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> edge option) -> t
val of_tree : Tree.t -> t
val of_hash_set : edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t :
edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t :
edge Bin_prot.Size.sizer
val bin_write_t :
edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash :
t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable :
t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b,
(key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t ->
key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update :
'b t -> key -> f:('b option -> 'b) -> unit
val add_multi :
'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi :
'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t ->
f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) ->
if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key ->
'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal :
'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t :
key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig
val t_of_sexp : Sexplib.Sexp.t -> elt
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t :
elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = edge
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map :
'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> edge -> Core_kernel__.Import.bool
val lookup :
'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> edge -> 'a
val enqueue :
'a t ->
edge -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val keys : 'a t -> edge Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> edge * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> edge -> Core_kernel__.Import.unit
val replace :
'a t -> edge -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:edge -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b ->
f:('b -> key:edge -> data:'a -> 'b) -> 'b
end
end
val empty : t
val nodes : t -> node Regular.Std.seq
val edges : t -> edge Regular.Std.seq
val is_directed : bool
val number_of_edges : t -> int
val number_of_nodes : t -> int
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = Edge.graph
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> Key.t
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> Key.t
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t :
Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = Edge.graph
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map :
t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> Elt.t
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> Elt.t
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t :
Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> Key.t -> Core_kernel__.Import.unit
val replace :
'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq :
Format.formatter -> t Core_kernel.Std.Sequence.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
end
module Labeled :
functor
(Node : Regular.Std.Opaque.S) (NL : Core_kernel.Std.T) (EL : Core_kernel.Std.T) ->
sig
type t
type node = (Node.t, NL.t) labeled
type edge
module Node :
sig
type t = node
type graph = t
type label = (Node.t, NL.t) labeled
type edge = edge
val create : label -> t
val label : t -> label
val mem : t -> graph -> bool
val succs : t -> graph -> t Regular.Std.seq
val preds : t -> graph -> t Regular.Std.seq
val inputs : t -> graph -> edge Regular.Std.seq
val outputs : t -> graph -> edge Regular.Std.seq
val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
val insert : t -> graph -> graph
val update : t -> label -> graph -> graph
val remove : t -> graph -> graph
val has_edge : t -> t -> graph -> bool
val edge : t -> t -> graph -> edge option
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = node
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(node, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : node -> 'a -> 'a t
val of_alist :
(node * 'a) list ->
[ `Duplicate_key of node | `Ok of 'a t ]
val of_alist_or_error :
(node * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (node * 'a) list -> 'a t
val of_alist_multi :
(node * 'a) list -> 'a list t
val of_alist_fold :
(node * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(node * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(node * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of node | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:node -> data:'a -> 'a t
val add_multi :
'a list t -> key:node -> data:'a -> 'a list t
val remove_multi : 'a list t -> node -> 'a list t
val change :
'a t ->
node -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> node -> f:('a option -> 'a) -> 'a t
val find : 'a t -> node -> 'a option
val find_exn : 'a t -> node -> 'a
val remove : 'a t -> node -> 'a t
val mem : 'a t -> node -> bool
val iter_keys : 'a t -> f:(node -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:node -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys :
'a t -> f:(node -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:node -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:node -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:node ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:node -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> node list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (node * 'a) list
val validate :
name:(node -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:node ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(node, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (node * 'a) option
val min_elt_exn : 'a t -> node * 'a
val max_elt : 'a t -> (node * 'a) option
val max_elt_exn : 'a t -> node * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:node -> data:'a -> bool) -> int
val split :
'a t ->
node -> 'a t * (node * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:node Base__.Maybe_bound.t ->
upper_bound:node Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:node ->
max:node ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t ->
min:node -> max:node -> (node * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> node -> (node * 'a) option
val nth : 'a t -> int -> (node * 'a) option
val nth_exn : 'a t -> int -> node * 'a
val rank : 'a t -> node -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:node ->
?keys_less_or_equal_to:node ->
'a t -> (node * 'a) Base__.Sequence.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(node, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : node -> 'a -> 'a t
val of_alist :
(node * 'a) list ->
[ `Duplicate_key of node | `Ok of 'a t ]
val of_alist_or_error :
(node * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (node * 'a) list -> 'a t
val of_alist_multi : (node * 'a) list -> 'a list t
val of_alist_fold :
(node * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(node * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(node * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of node | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:node -> data:'a -> 'a t
val add_multi :
'a list t -> key:node -> data:'a -> 'a list t
val remove_multi : 'a list t -> node -> 'a list t
val change :
'a t -> node -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> node -> f:('a option -> 'a) -> 'a t
val find : 'a t -> node -> 'a option
val find_exn : 'a t -> node -> 'a
val remove : 'a t -> node -> 'a t
val mem : 'a t -> node -> bool
val iter_keys : 'a t -> f:(node -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:node -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(node -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:node -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:node -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:node ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:node -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> node list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (node * 'a) list
val validate :
name:(node -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:node ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(node, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (node * 'a) option
val min_elt_exn : 'a t -> node * 'a
val max_elt : 'a t -> (node * 'a) option
val max_elt_exn : 'a t -> node * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:node -> data:'a -> bool) -> int
val split :
'a t -> node -> 'a t * (node * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:node Base__.Maybe_bound.t ->
upper_bound:node Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:node ->
max:node ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:node -> max:node -> (node * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> node -> (node * 'a) option
val nth : 'a t -> int -> (node * 'a) option
val nth_exn : 'a t -> int -> node * 'a
val rank : 'a t -> node -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:node ->
?keys_less_or_equal_to:node ->
'a t -> (node * 'a) Base__.Sequence.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : node Bin_prot.Type_class.t
val bin_read_t :
node Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> node)
Bin_prot.Read.reader
val bin_reader_t :
node Bin_prot.Type_class.reader
val bin_size_t :
node Bin_prot.Size.sizer
val bin_write_t :
node Bin_prot.Write.writer
val bin_writer_t :
node Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t :
('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t :
('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
node -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = node
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(node, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(node -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> node -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum ->
node -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(node -> bool) -> bool
val for_all : t -> f:(node -> bool) -> bool
val count : t -> f:(node -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(node -> 'sum) -> 'sum
val find : t -> f:(node -> bool) -> node option
val find_map :
t -> f:(node -> 'a option) -> 'a option
val to_list : t -> node list
val to_array : t -> node array
val invariants : t -> bool
val mem : t -> node -> bool
val add : t -> node -> t
val remove : t -> node -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(node, node) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
node ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of node * node
| `Left of node
| `Right of node ] -> unit) ->
unit
val filter : t -> f:(node -> bool) -> t
val partition_tf : t -> f:(node -> bool) -> t * t
val elements : t -> node list
val min_elt : t -> node option
val min_elt_exn : t -> node
val max_elt : t -> node option
val max_elt_exn : t -> node
val choose : t -> node option
val choose_exn : t -> node
val split : t -> node -> t * node option * t
val group_by :
t -> equiv:(node -> node -> bool) -> t list
val find_exn : t -> f:(node -> bool) -> node
val find_index : t -> int -> node option
val nth : t -> int -> node option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t -> node Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t ->
t ->
(node, node)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(node -> 'data) ->
(node, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : node -> t
val union_list : t list -> t
val of_list : node list -> t
val of_array : node array -> t
val of_sorted_array :
node array -> t Base__.Or_error.t
val of_sorted_array_unchecked : node array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node) -> t
val stable_dedup_list : node list -> node list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> node) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> node option) -> t
val of_tree : t -> t
val of_hash_set :
node Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(node, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(node, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp :
Sexplib.Sexp.t -> node
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (node, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(node -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> node -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(node -> bool) -> bool
val for_all : t -> f:(node -> bool) -> bool
val count : t -> f:(node -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(node -> 'sum) -> 'sum
val find : t -> f:(node -> bool) -> node option
val find_map :
t -> f:(node -> 'a option) -> 'a option
val to_list : t -> node list
val to_array : t -> node array
val invariants : t -> bool
val mem : t -> node -> bool
val add : t -> node -> t
val remove : t -> node -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (node, node) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
node ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of node * node
| `Left of node
| `Right of node ] -> unit) ->
unit
val filter : t -> f:(node -> bool) -> t
val partition_tf : t -> f:(node -> bool) -> t * t
val elements : t -> node list
val min_elt : t -> node option
val min_elt_exn : t -> node
val max_elt : t -> node option
val max_elt_exn : t -> node
val choose : t -> node option
val choose_exn : t -> node
val split : t -> node -> t * node option * t
val group_by :
t -> equiv:(node -> node -> bool) -> t list
val find_exn : t -> f:(node -> bool) -> node
val find_index : t -> int -> node option
val nth : t -> int -> node option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t -> node Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t ->
t ->
(node, node)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(node -> 'data) ->
(node, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : node -> t
val union_list : t list -> t
val of_list : node list -> t
val of_array : node array -> t
val of_sorted_array :
node array -> t Base__.Or_error.t
val of_sorted_array_unchecked : node array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node) -> t
val stable_dedup_list : node list -> node list
val map : ('a, 'b) Base.Set.t -> f:('a -> node) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> node option) -> t
val of_tree : Tree.t -> t
val of_hash_set : node Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(node, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(node, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : node Bin_prot.Type_class.t
val bin_read_t :
node Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> node)
Bin_prot.Read.reader
val bin_reader_t :
node Bin_prot.Type_class.reader
val bin_size_t :
node Bin_prot.Size.sizer
val bin_write_t :
node Bin_prot.Write.writer
val bin_writer_t :
node Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
node -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash :
t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable :
t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Equiv.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b,
(key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t ->
key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update :
'b t -> key -> f:('b option -> 'b) -> unit
val add_multi :
'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi :
'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t ->
f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) ->
if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key ->
'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal :
'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t :
key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig
val t_of_sexp : Sexplib.Sexp.t -> elt
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t :
elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = node
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map :
'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> node -> Core_kernel__.Import.bool
val lookup :
'a t -> node -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> node -> 'a
val enqueue :
'a t ->
node -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> node -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> node -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> node -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (node * 'a) Core_kernel__.Import.option
val keys : 'a t -> node Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (node * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> node * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> node -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> node -> Core_kernel__.Import.unit
val replace :
'a t -> node -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> node -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:node -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b ->
f:('b -> key:node -> data:'a -> 'b) -> 'b
end
end
module Edge :
sig
type t = edge
type node = Node.t
type graph = Node.graph
type label = EL.t
val create : node -> node -> label -> t
val label : t -> label
val src : t -> node
val dst : t -> node
val mem : t -> graph -> bool
val insert : t -> graph -> graph
val update : t -> label -> graph -> graph
val remove : t -> graph -> graph
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi :
(edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t ->
edge -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys :
'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t ->
edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t ->
min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi : (edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t -> edge -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t -> edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t :
edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t :
edge Bin_prot.Size.sizer
val bin_write_t :
edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t :
('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t :
('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(edge, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum ->
edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map :
t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by :
t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array :
edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge option) -> t
val of_tree : t -> t
val of_hash_set :
edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp :
Sexplib.Sexp.t -> edge
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (edge, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map :
t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by :
t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array :
edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map : ('a, 'b) Base.Set.t -> f:('a -> edge) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> edge option) -> t
val of_tree : Tree.t -> t
val of_hash_set : edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t :
edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t :
edge Bin_prot.Size.sizer
val bin_write_t :
edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash :
t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable :
t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b,
(key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t ->
key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update :
'b t -> key -> f:('b option -> 'b) -> unit
val add_multi :
'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi :
'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t ->
f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) ->
if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key ->
'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal :
'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t :
key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig
val t_of_sexp : Sexplib.Sexp.t -> elt
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t :
elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = edge
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map :
'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> edge -> Core_kernel__.Import.bool
val lookup :
'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> edge -> 'a
val enqueue :
'a t ->
edge -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val keys : 'a t -> edge Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> edge * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> edge -> Core_kernel__.Import.unit
val replace :
'a t -> edge -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:edge -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b ->
f:('b -> key:edge -> data:'a -> 'b) -> 'b
end
end
val empty : t
val nodes : t -> node Regular.Std.seq
val edges : t -> edge Regular.Std.seq
val is_directed : bool
val number_of_edges : t -> int
val number_of_nodes : t -> int
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = Edge.graph
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> Key.t
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> Key.t
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t :
Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = Edge.graph
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map :
t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> Elt.t
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> Elt.t
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t :
Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> Key.t -> Core_kernel__.Import.unit
val replace :
'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq :
Format.formatter -> t Core_kernel.Std.Sequence.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
end
val create :
(module Graphlib.Std.Graph with type t = 'c and type Edge.label = 'b and type Node.label = 'a) ->
?nodes:'a list -> ?edges:('a * 'a * 'b) list -> unit -> 'c
val union :
(module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
'c -> 'c -> 'c
val inter :
(module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
'c -> 'c -> 'c
val to_dot :
(module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
?graph_attrs:('c -> Graphlib.Std.graph_attr list) ->
?node_attrs:('n -> Graphlib.Std.node_attr list) ->
?edge_attrs:('e -> Graphlib.Std.edge_attr list) ->
?string_of_node:('n -> string) ->
?string_of_edge:('e -> string) ->
?channel:Core_kernel.Std.Out_channel.t ->
?formatter:Format.formatter -> ?filename:string -> 'c -> unit
val depth_first_search :
(module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
?rev:bool ->
?start:'n ->
?start_tree:('n -> 's -> 's) ->
?enter_node:(int -> 'n -> 's -> 's) ->
?leave_node:(int -> 'n -> 's -> 's) ->
?enter_edge:(Graphlib.Std.edge_kind -> 'e -> 's -> 's) ->
?leave_edge:(Graphlib.Std.edge_kind -> 'e -> 's -> 's) ->
'c -> init:'s -> 's
val depth_first_visit :
(module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
?rev:bool ->
?start:'n ->
'c -> init:'s -> ('n, 'e, 's) Graphlib.Std.dfs_visitor -> 's
class ['n, 'e, 's] dfs_identity_visitor : ['n, 'e, 's] dfs_visitor
val reverse_postorder_traverse :
(module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
?rev:bool -> ?start:'n -> 'c -> 'n Regular.Std.seq
val postorder_traverse :
(module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
?rev:bool -> ?start:'n -> 'c -> 'n Regular.Std.seq
val dominators :
(module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
?rev:bool -> 'c -> 'n -> 'n Graphlib.Std.tree
val dom_frontier :
(module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
?rev:bool ->
'c -> 'n Graphlib.Std.tree -> 'n Graphlib.Std.frontier
val strong_components :
(module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
'c -> 'n Graphlib.Std.partition
val shortest_path :
(module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
?weight:('e -> int) ->
?rev:bool -> 'c -> 'n -> 'n -> 'e Graphlib.Std.path option
val is_reachable :
(module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
?rev:bool -> 'c -> 'n -> 'n -> bool
val fold_reachable :
(module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
?rev:bool -> init:'a -> f:('a -> 'n -> 'a) -> 'c -> 'n -> 'a
val compare :
(module Graphlib.Std.Graph with type node = 'n and type t = 'a) ->
(module Graphlib.Std.Graph with type node = 'n and type t = 'b) ->
'a -> 'b -> int
val filtered :
(module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c) ->
?skip_node:('n -> bool) ->
?skip_edge:('e -> bool) ->
unit ->
(module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c)
val view :
(module Graphlib.Std.Graph with type edge = 'e and type node = 'n and type t = 'c and type Edge.label = 'b and type Node.label = 'a) ->
node:('n -> 'f) * ('f -> 'n) ->
edge:('e -> 'd) * ('d -> 'e) ->
node_label:('a -> 'p) * ('p -> 'a) ->
edge_label:('b -> 'r) * ('r -> 'b) ->
(module Graphlib.Std.Graph with type edge = 'd and type node = 'f and type t = 'c and type Edge.label = 'r and type Node.label = 'p)
module To_ocamlgraph :
functor (G : Graph) ->
sig
type t = G.t
module V :
sig
type t = G.node
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
type label = G.Node.label
val create : label -> t
val label : t -> label
end
type vertex = V.t
module E :
sig
type t = G.edge
val compare : t -> t -> int
type vertex = V.t
val src : t -> vertex
val dst : t -> vertex
type label = G.Edge.label
val create : vertex -> label -> vertex -> t
val label : t -> label
end
type edge = E.t
val is_directed : bool
val is_empty : t -> bool
val nb_vertex : t -> int
val nb_edges : t -> int
val out_degree : t -> vertex -> int
val in_degree : t -> vertex -> int
val mem_vertex : t -> vertex -> bool
val mem_edge : t -> vertex -> vertex -> bool
val mem_edge_e : t -> edge -> bool
val find_edge : t -> vertex -> vertex -> edge
val find_all_edges : t -> vertex -> vertex -> edge list
val succ : t -> vertex -> vertex list
val pred : t -> vertex -> vertex list
val succ_e : t -> vertex -> edge list
val pred_e : t -> vertex -> edge list
val iter_vertex : (vertex -> unit) -> t -> unit
val fold_vertex : (vertex -> 'a -> 'a) -> t -> 'a -> 'a
val iter_edges : (vertex -> vertex -> unit) -> t -> unit
val fold_edges :
(vertex -> vertex -> 'a -> 'a) -> t -> 'a -> 'a
val iter_edges_e : (edge -> unit) -> t -> unit
val fold_edges_e : (edge -> 'a -> 'a) -> t -> 'a -> 'a
val map_vertex : (vertex -> vertex) -> t -> t
val iter_succ : (vertex -> unit) -> t -> vertex -> unit
val iter_pred : (vertex -> unit) -> t -> vertex -> unit
val fold_succ :
(vertex -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val fold_pred :
(vertex -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val iter_succ_e : (edge -> unit) -> t -> vertex -> unit
val fold_succ_e :
(edge -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val iter_pred_e : (edge -> unit) -> t -> vertex -> unit
val fold_pred_e :
(edge -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val empty : t
val add_vertex : t -> vertex -> t
val remove_vertex : t -> vertex -> t
val add_edge : t -> vertex -> vertex -> t
val add_edge_e : t -> edge -> t
val remove_edge : t -> vertex -> vertex -> t
val remove_edge_e : t -> edge -> t
end
module Of_ocamlgraph :
functor (G : Graph.Sig.P) ->
sig
type t = G.t
type node = G.V.t
type edge = G.E.t
module Node :
sig
type t = node
type graph = G.t
type label = G.V.label
type edge = G.E.t
val create : label -> t
val label : t -> label
val mem : t -> graph -> bool
val succs : t -> graph -> t Regular.Std.seq
val preds : t -> graph -> t Regular.Std.seq
val inputs : t -> graph -> edge Regular.Std.seq
val outputs : t -> graph -> edge Regular.Std.seq
val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
val insert : t -> graph -> graph
val update : t -> label -> graph -> graph
val remove : t -> graph -> graph
val has_edge : t -> t -> graph -> bool
val edge : t -> t -> graph -> edge option
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = node
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(node, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : node -> 'a -> 'a t
val of_alist :
(node * 'a) list ->
[ `Duplicate_key of node | `Ok of 'a t ]
val of_alist_or_error :
(node * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (node * 'a) list -> 'a t
val of_alist_multi :
(node * 'a) list -> 'a list t
val of_alist_fold :
(node * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(node * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(node * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of node | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:node -> data:'a -> 'a t
val add_multi :
'a list t -> key:node -> data:'a -> 'a list t
val remove_multi : 'a list t -> node -> 'a list t
val change :
'a t ->
node -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> node -> f:('a option -> 'a) -> 'a t
val find : 'a t -> node -> 'a option
val find_exn : 'a t -> node -> 'a
val remove : 'a t -> node -> 'a t
val mem : 'a t -> node -> bool
val iter_keys : 'a t -> f:(node -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:node -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys :
'a t -> f:(node -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:node -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:node -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:node ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:node -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> node list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (node * 'a) list
val validate :
name:(node -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:node ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(node, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (node * 'a) option
val min_elt_exn : 'a t -> node * 'a
val max_elt : 'a t -> (node * 'a) option
val max_elt_exn : 'a t -> node * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:node -> data:'a -> bool) -> int
val split :
'a t ->
node -> 'a t * (node * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:node Base__.Maybe_bound.t ->
upper_bound:node Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:node ->
max:node ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t ->
min:node -> max:node -> (node * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> node -> (node * 'a) option
val nth : 'a t -> int -> (node * 'a) option
val nth_exn : 'a t -> int -> node * 'a
val rank : 'a t -> node -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:node ->
?keys_less_or_equal_to:node ->
'a t -> (node * 'a) Base__.Sequence.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(node, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : node -> 'a -> 'a t
val of_alist :
(node * 'a) list ->
[ `Duplicate_key of node | `Ok of 'a t ]
val of_alist_or_error :
(node * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (node * 'a) list -> 'a t
val of_alist_multi : (node * 'a) list -> 'a list t
val of_alist_fold :
(node * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(node * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(node * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of node | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:node -> data:'a -> 'a t
val add_multi :
'a list t -> key:node -> data:'a -> 'a list t
val remove_multi : 'a list t -> node -> 'a list t
val change :
'a t -> node -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> node -> f:('a option -> 'a) -> 'a t
val find : 'a t -> node -> 'a option
val find_exn : 'a t -> node -> 'a
val remove : 'a t -> node -> 'a t
val mem : 'a t -> node -> bool
val iter_keys : 'a t -> f:(node -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:node -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(node -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:node -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:node -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:node ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:node -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> node list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (node * 'a) list
val validate :
name:(node -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:node ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(node, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (node * 'a) option
val min_elt_exn : 'a t -> node * 'a
val max_elt : 'a t -> (node * 'a) option
val max_elt_exn : 'a t -> node * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:node -> data:'a -> bool) -> int
val split :
'a t -> node -> 'a t * (node * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:node Base__.Maybe_bound.t ->
upper_bound:node Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:node ->
max:node ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:node -> max:node -> (node * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> node -> (node * 'a) option
val nth : 'a t -> int -> (node * 'a) option
val nth_exn : 'a t -> int -> node * 'a
val rank : 'a t -> node -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:node ->
?keys_less_or_equal_to:node ->
'a t -> (node * 'a) Base__.Sequence.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : node Bin_prot.Type_class.t
val bin_read_t :
node Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> node)
Bin_prot.Read.reader
val bin_reader_t :
node Bin_prot.Type_class.reader
val bin_size_t :
node Bin_prot.Size.sizer
val bin_write_t :
node Bin_prot.Write.writer
val bin_writer_t :
node Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t :
('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t :
('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
node -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = node
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(node, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(node -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> node -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum ->
node -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(node -> bool) -> bool
val for_all : t -> f:(node -> bool) -> bool
val count : t -> f:(node -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(node -> 'sum) -> 'sum
val find : t -> f:(node -> bool) -> node option
val find_map :
t -> f:(node -> 'a option) -> 'a option
val to_list : t -> node list
val to_array : t -> node array
val invariants : t -> bool
val mem : t -> node -> bool
val add : t -> node -> t
val remove : t -> node -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(node, node) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
node ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of node * node
| `Left of node
| `Right of node ] -> unit) ->
unit
val filter : t -> f:(node -> bool) -> t
val partition_tf : t -> f:(node -> bool) -> t * t
val elements : t -> node list
val min_elt : t -> node option
val min_elt_exn : t -> node
val max_elt : t -> node option
val max_elt_exn : t -> node
val choose : t -> node option
val choose_exn : t -> node
val split : t -> node -> t * node option * t
val group_by :
t -> equiv:(node -> node -> bool) -> t list
val find_exn : t -> f:(node -> bool) -> node
val find_index : t -> int -> node option
val nth : t -> int -> node option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t -> node Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t ->
t ->
(node, node)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(node -> 'data) ->
(node, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : node -> t
val union_list : t list -> t
val of_list : node list -> t
val of_array : node array -> t
val of_sorted_array :
node array -> t Base__.Or_error.t
val of_sorted_array_unchecked : node array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node) -> t
val stable_dedup_list : node list -> node list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> node) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> node option) -> t
val of_tree : t -> t
val of_hash_set :
node Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(node, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(node, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp :
Sexplib.Sexp.t -> node
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (node, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(node -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> node -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(node -> bool) -> bool
val for_all : t -> f:(node -> bool) -> bool
val count : t -> f:(node -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(node -> 'sum) -> 'sum
val find : t -> f:(node -> bool) -> node option
val find_map :
t -> f:(node -> 'a option) -> 'a option
val to_list : t -> node list
val to_array : t -> node array
val invariants : t -> bool
val mem : t -> node -> bool
val add : t -> node -> t
val remove : t -> node -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (node, node) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
node ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of node * node
| `Left of node
| `Right of node ] -> unit) ->
unit
val filter : t -> f:(node -> bool) -> t
val partition_tf : t -> f:(node -> bool) -> t * t
val elements : t -> node list
val min_elt : t -> node option
val min_elt_exn : t -> node
val max_elt : t -> node option
val max_elt_exn : t -> node
val choose : t -> node option
val choose_exn : t -> node
val split : t -> node -> t * node option * t
val group_by :
t -> equiv:(node -> node -> bool) -> t list
val find_exn : t -> f:(node -> bool) -> node
val find_index : t -> int -> node option
val nth : t -> int -> node option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t -> node Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t ->
t ->
(node, node)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(node -> 'data) ->
(node, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : node -> t
val union_list : t list -> t
val of_list : node list -> t
val of_array : node array -> t
val of_sorted_array :
node array -> t Base__.Or_error.t
val of_sorted_array_unchecked : node array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node) -> t
val stable_dedup_list : node list -> node list
val map : ('a, 'b) Base.Set.t -> f:('a -> node) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> node option) -> t
val of_tree : Tree.t -> t
val of_hash_set : node Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(node, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(node, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : node Bin_prot.Type_class.t
val bin_read_t :
node Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> node)
Bin_prot.Read.reader
val bin_reader_t :
node Bin_prot.Type_class.reader
val bin_size_t :
node Bin_prot.Size.sizer
val bin_write_t :
node Bin_prot.Write.writer
val bin_writer_t :
node Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
node -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash :
t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable :
t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Equiv.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b,
(key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t ->
key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update :
'b t -> key -> f:('b option -> 'b) -> unit
val add_multi :
'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi :
'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t ->
f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) ->
if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key ->
'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal :
'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t :
key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig
val t_of_sexp : Sexplib.Sexp.t -> elt
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t :
elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = node
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map :
'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> node -> Core_kernel__.Import.bool
val lookup :
'a t -> node -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> node -> 'a
val enqueue :
'a t ->
node -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> node -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> node -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> node -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (node * 'a) Core_kernel__.Import.option
val keys : 'a t -> node Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (node * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> node * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> node -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> node -> Core_kernel__.Import.unit
val replace :
'a t -> node -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> node -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:node -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b ->
f:('b -> key:node -> data:'a -> 'b) -> 'b
end
end
module Edge :
sig
type t = edge
type node = Node.t
type graph = Node.graph
type label = G.E.label
val create : node -> node -> label -> t
val label : t -> label
val src : t -> node
val dst : t -> node
val mem : t -> graph -> bool
val insert : t -> graph -> graph
val update : t -> label -> graph -> graph
val remove : t -> graph -> graph
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi :
(edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t ->
edge -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys :
'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t ->
edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t ->
min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi : (edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t -> edge -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t -> edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t :
edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t :
edge Bin_prot.Size.sizer
val bin_write_t :
edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t :
('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t :
('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(edge, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum ->
edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map :
t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by :
t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array :
edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge option) -> t
val of_tree : t -> t
val of_hash_set :
edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp :
Sexplib.Sexp.t -> edge
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (edge, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map :
t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by :
t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array :
edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map : ('a, 'b) Base.Set.t -> f:('a -> edge) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> edge option) -> t
val of_tree : Tree.t -> t
val of_hash_set : edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t :
edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t :
edge Bin_prot.Size.sizer
val bin_write_t :
edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash :
t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable :
t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b,
(key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t ->
key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update :
'b t -> key -> f:('b option -> 'b) -> unit
val add_multi :
'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi :
'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t ->
f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) ->
if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key ->
'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal :
'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t :
key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig
val t_of_sexp : Sexplib.Sexp.t -> elt
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t :
elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = edge
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map :
'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> edge -> Core_kernel__.Import.bool
val lookup :
'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> edge -> 'a
val enqueue :
'a t ->
edge -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val keys : 'a t -> edge Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> edge * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> edge -> Core_kernel__.Import.unit
val replace :
'a t -> edge -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:edge -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b ->
f:('b -> key:edge -> data:'a -> 'b) -> 'b
end
end
val empty : t
val nodes : t -> node Regular.Std.seq
val edges : t -> edge Regular.Std.seq
val is_directed : bool
val number_of_edges : t -> int
val number_of_nodes : t -> int
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = Edge.graph
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> Key.t
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> Key.t
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t :
Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = Edge.graph
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map :
t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> Elt.t
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> Elt.t
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t :
Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> Key.t -> Core_kernel__.Import.unit
val replace :
'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq :
Format.formatter -> t Core_kernel.Std.Sequence.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
end
module Filtered :
functor
(G : Graph) (P : sig
type edge = G.edge
type node = G.node
val edge : edge -> bool
val node : node -> bool
end) ->
sig
type t = G.t
type node = P.node
type edge = P.edge
module Node :
sig
type t = node
type graph = G.t
type label = G.Node.label
type edge = P.edge
val create : label -> t
val label : t -> label
val mem : t -> graph -> bool
val succs : t -> graph -> t Regular.Std.seq
val preds : t -> graph -> t Regular.Std.seq
val inputs : t -> graph -> edge Regular.Std.seq
val outputs : t -> graph -> edge Regular.Std.seq
val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
val insert : t -> graph -> graph
val update : t -> label -> graph -> graph
val remove : t -> graph -> graph
val has_edge : t -> t -> graph -> bool
val edge : t -> t -> graph -> edge option
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness = G.Node.comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = node
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
G.Node.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(node, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : node -> 'a -> 'a t
val of_alist :
(node * 'a) list ->
[ `Duplicate_key of node | `Ok of 'a t ]
val of_alist_or_error :
(node * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (node * 'a) list -> 'a t
val of_alist_multi :
(node * 'a) list -> 'a list t
val of_alist_fold :
(node * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(node * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(node * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of node | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:node -> data:'a -> 'a t
val add_multi :
'a list t -> key:node -> data:'a -> 'a list t
val remove_multi : 'a list t -> node -> 'a list t
val change :
'a t ->
node -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> node -> f:('a option -> 'a) -> 'a t
val find : 'a t -> node -> 'a option
val find_exn : 'a t -> node -> 'a
val remove : 'a t -> node -> 'a t
val mem : 'a t -> node -> bool
val iter_keys : 'a t -> f:(node -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:node -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys :
'a t -> f:(node -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:node -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:node -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:node ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:node -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> node list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (node * 'a) list
val validate :
name:(node -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:node ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(node, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (node * 'a) option
val min_elt_exn : 'a t -> node * 'a
val max_elt : 'a t -> (node * 'a) option
val max_elt_exn : 'a t -> node * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:node -> data:'a -> bool) -> int
val split :
'a t ->
node -> 'a t * (node * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:node Base__.Maybe_bound.t ->
upper_bound:node Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:node ->
max:node ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t ->
min:node -> max:node -> (node * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> node -> (node * 'a) option
val nth : 'a t -> int -> (node * 'a) option
val nth_exn : 'a t -> int -> node * 'a
val rank : 'a t -> node -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:node ->
?keys_less_or_equal_to:node ->
'a t -> (node * 'a) Base__.Sequence.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(node, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : node -> 'a -> 'a t
val of_alist :
(node * 'a) list ->
[ `Duplicate_key of node | `Ok of 'a t ]
val of_alist_or_error :
(node * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (node * 'a) list -> 'a t
val of_alist_multi : (node * 'a) list -> 'a list t
val of_alist_fold :
(node * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(node * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(node * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of node | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:node -> data:'a -> 'a t
val add_multi :
'a list t -> key:node -> data:'a -> 'a list t
val remove_multi : 'a list t -> node -> 'a list t
val change :
'a t -> node -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> node -> f:('a option -> 'a) -> 'a t
val find : 'a t -> node -> 'a option
val find_exn : 'a t -> node -> 'a
val remove : 'a t -> node -> 'a t
val mem : 'a t -> node -> bool
val iter_keys : 'a t -> f:(node -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:node -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(node -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:node -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:node -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:node ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:node -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> node list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (node * 'a) list
val validate :
name:(node -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:node ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(node, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (node * 'a) option
val min_elt_exn : 'a t -> node * 'a
val max_elt : 'a t -> (node * 'a) option
val max_elt_exn : 'a t -> node * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:node -> data:'a -> bool) -> int
val split :
'a t -> node -> 'a t * (node * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:node Base__.Maybe_bound.t ->
upper_bound:node Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:node ->
max:node ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:node -> max:node -> (node * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> node -> (node * 'a) option
val nth : 'a t -> int -> (node * 'a) option
val nth_exn : 'a t -> int -> node * 'a
val rank : 'a t -> node -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:node ->
?keys_less_or_equal_to:node ->
'a t -> (node * 'a) Base__.Sequence.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : node Bin_prot.Type_class.t
val bin_read_t :
node Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> node)
Bin_prot.Read.reader
val bin_reader_t :
node Bin_prot.Type_class.reader
val bin_size_t :
node Bin_prot.Size.sizer
val bin_write_t :
node Bin_prot.Write.writer
val bin_writer_t :
node Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t :
('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t :
('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
node -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = node
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(node, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(node -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> node -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum ->
node -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(node -> bool) -> bool
val for_all : t -> f:(node -> bool) -> bool
val count : t -> f:(node -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(node -> 'sum) -> 'sum
val find : t -> f:(node -> bool) -> node option
val find_map :
t -> f:(node -> 'a option) -> 'a option
val to_list : t -> node list
val to_array : t -> node array
val invariants : t -> bool
val mem : t -> node -> bool
val add : t -> node -> t
val remove : t -> node -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(node, node) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
node ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of node * node
| `Left of node
| `Right of node ] -> unit) ->
unit
val filter : t -> f:(node -> bool) -> t
val partition_tf : t -> f:(node -> bool) -> t * t
val elements : t -> node list
val min_elt : t -> node option
val min_elt_exn : t -> node
val max_elt : t -> node option
val max_elt_exn : t -> node
val choose : t -> node option
val choose_exn : t -> node
val split : t -> node -> t * node option * t
val group_by :
t -> equiv:(node -> node -> bool) -> t list
val find_exn : t -> f:(node -> bool) -> node
val find_index : t -> int -> node option
val nth : t -> int -> node option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t -> node Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t ->
t ->
(node, node)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(node -> 'data) ->
(node, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : node -> t
val union_list : t list -> t
val of_list : node list -> t
val of_array : node array -> t
val of_sorted_array :
node array -> t Base__.Or_error.t
val of_sorted_array_unchecked : node array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node) -> t
val stable_dedup_list : node list -> node list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> node) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> node option) -> t
val of_tree : t -> t
val of_hash_set :
node Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(node, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(node, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp :
Sexplib.Sexp.t -> node
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (node, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(node -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> node -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(node -> bool) -> bool
val for_all : t -> f:(node -> bool) -> bool
val count : t -> f:(node -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(node -> 'sum) -> 'sum
val find : t -> f:(node -> bool) -> node option
val find_map :
t -> f:(node -> 'a option) -> 'a option
val to_list : t -> node list
val to_array : t -> node array
val invariants : t -> bool
val mem : t -> node -> bool
val add : t -> node -> t
val remove : t -> node -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (node, node) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
node ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of node * node
| `Left of node
| `Right of node ] -> unit) ->
unit
val filter : t -> f:(node -> bool) -> t
val partition_tf : t -> f:(node -> bool) -> t * t
val elements : t -> node list
val min_elt : t -> node option
val min_elt_exn : t -> node
val max_elt : t -> node option
val max_elt_exn : t -> node
val choose : t -> node option
val choose_exn : t -> node
val split : t -> node -> t * node option * t
val group_by :
t -> equiv:(node -> node -> bool) -> t list
val find_exn : t -> f:(node -> bool) -> node
val find_index : t -> int -> node option
val nth : t -> int -> node option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t -> node Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t ->
t ->
(node, node)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(node -> 'data) ->
(node, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : node -> t
val union_list : t list -> t
val of_list : node list -> t
val of_array : node array -> t
val of_sorted_array :
node array -> t Base__.Or_error.t
val of_sorted_array_unchecked : node array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node) -> t
val stable_dedup_list : node list -> node list
val map : ('a, 'b) Base.Set.t -> f:('a -> node) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> node option) -> t
val of_tree : Tree.t -> t
val of_hash_set : node Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(node, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(node, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : node Bin_prot.Type_class.t
val bin_read_t :
node Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> node)
Bin_prot.Read.reader
val bin_reader_t :
node Bin_prot.Type_class.reader
val bin_size_t :
node Bin_prot.Size.sizer
val bin_write_t :
node Bin_prot.Write.writer
val bin_writer_t :
node Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
node -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash :
t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable :
t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) G.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b,
(key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t ->
key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update :
'b t -> key -> f:('b option -> 'b) -> unit
val add_multi :
'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi :
'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t ->
f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) ->
if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action =
'a G.Node.Table.merge_into_action =
Remove
| Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key ->
'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal :
'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t :
key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig
val t_of_sexp : Sexplib.Sexp.t -> elt
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t :
elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = node
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t = 'a G.Node.Hash_queue.t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map :
'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> node -> Core_kernel__.Import.bool
val lookup :
'a t -> node -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> node -> 'a
val enqueue :
'a t ->
node -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> node -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> node -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> node -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (node * 'a) Core_kernel__.Import.option
val keys : 'a t -> node Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (node * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> node * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> node -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> node -> Core_kernel__.Import.unit
val replace :
'a t -> node -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> node -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:node -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b ->
f:('b -> key:node -> data:'a -> 'b) -> 'b
end
end
module Edge :
sig
type t = edge
type node = Node.t
type graph = Node.graph
type label = G.Edge.label
val create : node -> node -> label -> t
val label : t -> label
val src : t -> node
val dst : t -> node
val mem : t -> graph -> bool
val insert : t -> graph -> graph
val update : t -> label -> graph -> graph
val remove : t -> graph -> graph
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness = G.Edge.comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
G.Edge.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi :
(edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t ->
edge -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys :
'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t ->
edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t ->
min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi : (edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t -> edge -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t -> edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t :
edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t :
edge Bin_prot.Size.sizer
val bin_write_t :
edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t :
('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t :
('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(edge, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum ->
edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map :
t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by :
t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array :
edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge option) -> t
val of_tree : t -> t
val of_hash_set :
edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp :
Sexplib.Sexp.t -> edge
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (edge, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map :
t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by :
t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array :
edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map : ('a, 'b) Base.Set.t -> f:('a -> edge) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> edge option) -> t
val of_tree : Tree.t -> t
val of_hash_set : edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t :
edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t :
edge Bin_prot.Size.sizer
val bin_write_t :
edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash :
t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable :
t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b,
(key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t ->
key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update :
'b t -> key -> f:('b option -> 'b) -> unit
val add_multi :
'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi :
'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t ->
f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) ->
if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action =
'a G.Edge.Table.merge_into_action =
Remove
| Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key ->
'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal :
'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t :
key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig
val t_of_sexp : Sexplib.Sexp.t -> elt
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t :
elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = edge
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t = 'a G.Edge.Hash_queue.t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map :
'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> edge -> Core_kernel__.Import.bool
val lookup :
'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> edge -> 'a
val enqueue :
'a t ->
edge -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val keys : 'a t -> edge Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> edge * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> edge -> Core_kernel__.Import.unit
val replace :
'a t -> edge -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:edge -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b ->
f:('b -> key:edge -> data:'a -> 'b) -> 'b
end
end
val empty : t
val nodes : t -> node Regular.Std.seq
val edges : t -> edge Regular.Std.seq
val is_directed : bool
val number_of_edges : t -> int
val number_of_nodes : t -> int
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = Edge.graph
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> Key.t
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> Key.t
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t :
Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = Edge.graph
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map :
t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> Elt.t
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> Elt.t
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t :
Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> Key.t -> Core_kernel__.Import.unit
val replace :
'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq :
Format.formatter -> t Core_kernel.Std.Sequence.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
end
module Mapper :
functor
(G : Graph) (N : sig
type s = G.node
type t
val forward : s -> t
val backward : t -> s
end) (E : sig
type s = G.edge
type t
val forward : s -> t
val backward : t -> s
end) (NL : sig
type s = G.Node.label
type t
val forward : s -> t
val backward : t -> s
end) (EL : sig
type s =
G.Edge.label
type t
val forward :
s -> t
val backward :
t -> s
end) ->
sig
type t = G.t
type node = N.t
type edge = E.t
module Node :
sig
type t = node
type graph = G.t
type label = NL.t
type edge = E.t
val create : label -> t
val label : t -> label
val mem : t -> graph -> bool
val succs : t -> graph -> t Regular.Std.seq
val preds : t -> graph -> t Regular.Std.seq
val inputs : t -> graph -> edge Regular.Std.seq
val outputs : t -> graph -> edge Regular.Std.seq
val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
val insert : t -> graph -> graph
val update : t -> label -> graph -> graph
val remove : t -> graph -> graph
val has_edge : t -> t -> graph -> bool
val edge : t -> t -> graph -> edge option
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = node
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(node, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : node -> 'a -> 'a t
val of_alist :
(node * 'a) list ->
[ `Duplicate_key of node | `Ok of 'a t ]
val of_alist_or_error :
(node * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (node * 'a) list -> 'a t
val of_alist_multi :
(node * 'a) list -> 'a list t
val of_alist_fold :
(node * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(node * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(node * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of node | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:node -> data:'a -> 'a t
val add_multi :
'a list t -> key:node -> data:'a -> 'a list t
val remove_multi : 'a list t -> node -> 'a list t
val change :
'a t ->
node -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> node -> f:('a option -> 'a) -> 'a t
val find : 'a t -> node -> 'a option
val find_exn : 'a t -> node -> 'a
val remove : 'a t -> node -> 'a t
val mem : 'a t -> node -> bool
val iter_keys : 'a t -> f:(node -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:node -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys :
'a t -> f:(node -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:node -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:node -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:node ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:node -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> node list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (node * 'a) list
val validate :
name:(node -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:node ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(node, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (node * 'a) option
val min_elt_exn : 'a t -> node * 'a
val max_elt : 'a t -> (node * 'a) option
val max_elt_exn : 'a t -> node * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:node -> data:'a -> bool) -> int
val split :
'a t ->
node -> 'a t * (node * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:node Base__.Maybe_bound.t ->
upper_bound:node Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:node ->
max:node ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t ->
min:node -> max:node -> (node * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> node -> (node * 'a) option
val nth : 'a t -> int -> (node * 'a) option
val nth_exn : 'a t -> int -> node * 'a
val rank : 'a t -> node -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:node ->
?keys_less_or_equal_to:node ->
'a t -> (node * 'a) Base__.Sequence.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(node, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : node -> 'a -> 'a t
val of_alist :
(node * 'a) list ->
[ `Duplicate_key of node | `Ok of 'a t ]
val of_alist_or_error :
(node * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (node * 'a) list -> 'a t
val of_alist_multi : (node * 'a) list -> 'a list t
val of_alist_fold :
(node * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(node * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(node * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(node * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:node -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of node | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:node -> data:'a -> 'a t
val add_multi :
'a list t -> key:node -> data:'a -> 'a list t
val remove_multi : 'a list t -> node -> 'a list t
val change :
'a t -> node -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> node -> f:('a option -> 'a) -> 'a t
val find : 'a t -> node -> 'a option
val find_exn : 'a t -> node -> 'a
val remove : 'a t -> node -> 'a t
val mem : 'a t -> node -> bool
val iter_keys : 'a t -> f:(node -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:node -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:node -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:node ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(node -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:node -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:node -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:node ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:node -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> node list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (node * 'a) list
val validate :
name:(node -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:node ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(node, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (node * 'a) option
val min_elt_exn : 'a t -> node * 'a
val max_elt : 'a t -> (node * 'a) option
val max_elt_exn : 'a t -> node * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:node -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:node -> data:'a -> bool) -> int
val split :
'a t -> node -> 'a t * (node * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:node Base__.Maybe_bound.t ->
upper_bound:node Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:node ->
max:node ->
init:'b ->
f:(key:node -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:node -> max:node -> (node * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> node -> (node * 'a) option
val nth : 'a t -> int -> (node * 'a) option
val nth_exn : 'a t -> int -> node * 'a
val rank : 'a t -> node -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:node ->
?keys_less_or_equal_to:node ->
'a t -> (node * 'a) Base__.Sequence.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : node Bin_prot.Type_class.t
val bin_read_t :
node Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> node)
Bin_prot.Read.reader
val bin_reader_t :
node Bin_prot.Type_class.reader
val bin_size_t :
node Bin_prot.Size.sizer
val bin_write_t :
node Bin_prot.Write.writer
val bin_writer_t :
node Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t :
('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t :
('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
node -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = node
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(node, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(node -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> node -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum ->
node -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(node -> bool) -> bool
val for_all : t -> f:(node -> bool) -> bool
val count : t -> f:(node -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(node -> 'sum) -> 'sum
val find : t -> f:(node -> bool) -> node option
val find_map :
t -> f:(node -> 'a option) -> 'a option
val to_list : t -> node list
val to_array : t -> node array
val invariants : t -> bool
val mem : t -> node -> bool
val add : t -> node -> t
val remove : t -> node -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(node, node) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
node ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of node * node
| `Left of node
| `Right of node ] -> unit) ->
unit
val filter : t -> f:(node -> bool) -> t
val partition_tf : t -> f:(node -> bool) -> t * t
val elements : t -> node list
val min_elt : t -> node option
val min_elt_exn : t -> node
val max_elt : t -> node option
val max_elt_exn : t -> node
val choose : t -> node option
val choose_exn : t -> node
val split : t -> node -> t * node option * t
val group_by :
t -> equiv:(node -> node -> bool) -> t list
val find_exn : t -> f:(node -> bool) -> node
val find_index : t -> int -> node option
val nth : t -> int -> node option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t -> node Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t ->
t ->
(node, node)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(node -> 'data) ->
(node, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : node -> t
val union_list : t list -> t
val of_list : node list -> t
val of_array : node array -> t
val of_sorted_array :
node array -> t Base__.Or_error.t
val of_sorted_array_unchecked : node array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node) -> t
val stable_dedup_list : node list -> node list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> node) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> node option) -> t
val of_tree : t -> t
val of_hash_set :
node Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(node, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(node, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp :
Sexplib.Sexp.t -> node
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (node, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(node -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> node -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(node -> bool) -> bool
val for_all : t -> f:(node -> bool) -> bool
val count : t -> f:(node -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(node -> 'sum) -> 'sum
val find : t -> f:(node -> bool) -> node option
val find_map :
t -> f:(node -> 'a option) -> 'a option
val to_list : t -> node list
val to_array : t -> node array
val invariants : t -> bool
val mem : t -> node -> bool
val add : t -> node -> t
val remove : t -> node -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (node, node) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
node ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(node -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of node * node
| `Left of node
| `Right of node ] -> unit) ->
unit
val filter : t -> f:(node -> bool) -> t
val partition_tf : t -> f:(node -> bool) -> t * t
val elements : t -> node list
val min_elt : t -> node option
val min_elt_exn : t -> node
val max_elt : t -> node option
val max_elt_exn : t -> node
val choose : t -> node option
val choose_exn : t -> node
val split : t -> node -> t * node option * t
val group_by :
t -> equiv:(node -> node -> bool) -> t list
val find_exn : t -> f:(node -> bool) -> node
val find_index : t -> int -> node option
val nth : t -> int -> node option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t -> node Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:node ->
?less_or_equal_to:node ->
t ->
t ->
(node, node)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(node -> 'data) ->
(node, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
node Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
node Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : node -> t
val union_list : t list -> t
val of_list : node list -> t
val of_array : node array -> t
val of_sorted_array :
node array -> t Base__.Or_error.t
val of_sorted_array_unchecked : node array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> node) -> t
val stable_dedup_list : node list -> node list
val map : ('a, 'b) Base.Set.t -> f:('a -> node) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> node option) -> t
val of_tree : Tree.t -> t
val of_hash_set : node Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(node, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(node, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
node Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> node
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : node Bin_prot.Type_class.t
val bin_read_t :
node Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> node)
Bin_prot.Read.reader
val bin_reader_t :
node Bin_prot.Type_class.reader
val bin_size_t :
node Bin_prot.Size.sizer
val bin_write_t :
node Bin_prot.Write.writer
val bin_writer_t :
node Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
node -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash :
t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable :
t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) G.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b,
(key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t ->
key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update :
'b t -> key -> f:('b option -> 'b) -> unit
val add_multi :
'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi :
'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t ->
f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) ->
if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key ->
'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal :
'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t :
key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig
val t_of_sexp : Sexplib.Sexp.t -> elt
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t :
elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = node
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map :
'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> node -> Core_kernel__.Import.bool
val lookup :
'a t -> node -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> node -> 'a
val enqueue :
'a t ->
node -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> node -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> node -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> node -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (node * 'a) Core_kernel__.Import.option
val keys : 'a t -> node Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (node * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> node * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> node -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> node -> Core_kernel__.Import.unit
val replace :
'a t -> node -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> node -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:node -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b ->
f:('b -> key:node -> data:'a -> 'b) -> 'b
end
end
module Edge :
sig
type t = edge
type node = Node.t
type graph = Node.graph
type label = EL.t
val create : node -> node -> label -> t
val label : t -> label
val src : t -> node
val dst : t -> node
val mem : t -> graph -> bool
val insert : t -> graph -> graph
val update : t -> label -> graph -> graph
val remove : t -> graph -> graph
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi :
(edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t ->
edge -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys :
'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t ->
edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t ->
min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(edge, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : edge -> 'a -> 'a t
val of_alist :
(edge * 'a) list ->
[ `Duplicate_key of edge | `Ok of 'a t ]
val of_alist_or_error :
(edge * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (edge * 'a) list -> 'a t
val of_alist_multi : (edge * 'a) list -> 'a list t
val of_alist_fold :
(edge * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(edge * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(edge * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(edge * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:edge -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of edge | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:edge -> data:'a -> 'a t
val add_multi :
'a list t -> key:edge -> data:'a -> 'a list t
val remove_multi : 'a list t -> edge -> 'a list t
val change :
'a t -> edge -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> edge -> f:('a option -> 'a) -> 'a t
val find : 'a t -> edge -> 'a option
val find_exn : 'a t -> edge -> 'a
val remove : 'a t -> edge -> 'a t
val mem : 'a t -> edge -> bool
val iter_keys : 'a t -> f:(edge -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:edge -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:edge -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:edge ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:edge -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:edge -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:edge ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:edge -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> edge list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (edge * 'a) list
val validate :
name:(edge -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:edge ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(edge, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (edge * 'a) option
val min_elt_exn : 'a t -> edge * 'a
val max_elt : 'a t -> (edge * 'a) option
val max_elt_exn : 'a t -> edge * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:edge -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:edge -> data:'a -> bool) -> int
val split :
'a t -> edge -> 'a t * (edge * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:edge Base__.Maybe_bound.t ->
upper_bound:edge Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:edge ->
max:edge ->
init:'b ->
f:(key:edge -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:edge -> max:edge -> (edge * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> edge -> (edge * 'a) option
val nth : 'a t -> int -> (edge * 'a) option
val nth_exn : 'a t -> int -> edge * 'a
val rank : 'a t -> edge -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:edge ->
?keys_less_or_equal_to:edge ->
'a t -> (edge * 'a) Base__.Sequence.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t :
edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t :
edge Bin_prot.Size.sizer
val bin_write_t :
edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t :
('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t :
('a, 'a t) Bin_prot.Write.writer1
val bin_read_t :
('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = edge
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness =
Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(edge, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum ->
edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map :
t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by :
t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array :
edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> edge option) -> t
val of_tree : t -> t
val of_hash_set :
edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp :
Sexplib.Sexp.t -> edge
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (edge, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(edge -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> edge -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(edge -> bool) -> bool
val for_all : t -> f:(edge -> bool) -> bool
val count : t -> f:(edge -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(edge -> 'sum) -> 'sum
val find : t -> f:(edge -> bool) -> edge option
val find_map :
t -> f:(edge -> 'a option) -> 'a option
val to_list : t -> edge list
val to_array : t -> edge array
val invariants : t -> bool
val mem : t -> edge -> bool
val add : t -> edge -> t
val remove : t -> edge -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (edge, edge) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
edge ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(edge -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of edge * edge
| `Left of edge
| `Right of edge ] -> unit) ->
unit
val filter : t -> f:(edge -> bool) -> t
val partition_tf : t -> f:(edge -> bool) -> t * t
val elements : t -> edge list
val min_elt : t -> edge option
val min_elt_exn : t -> edge
val max_elt : t -> edge option
val max_elt_exn : t -> edge
val choose : t -> edge option
val choose_exn : t -> edge
val split : t -> edge -> t * edge option * t
val group_by :
t -> equiv:(edge -> edge -> bool) -> t list
val find_exn : t -> f:(edge -> bool) -> edge
val find_index : t -> int -> edge option
val nth : t -> int -> edge option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t -> edge Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:edge ->
?less_or_equal_to:edge ->
t ->
t ->
(edge, edge)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(edge -> 'data) ->
(edge, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
edge Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
edge Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : edge -> t
val union_list : t list -> t
val of_list : edge list -> t
val of_array : edge array -> t
val of_sorted_array :
edge array -> t Base__.Or_error.t
val of_sorted_array_unchecked : edge array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> edge) -> t
val stable_dedup_list : edge list -> edge list
val map : ('a, 'b) Base.Set.t -> f:('a -> edge) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> edge option) -> t
val of_tree : Tree.t -> t
val of_hash_set : edge Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(edge, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(edge, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
edge Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> edge
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : edge Bin_prot.Type_class.t
val bin_read_t :
edge Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> edge)
Bin_prot.Read.reader
val bin_reader_t :
edge Bin_prot.Type_class.reader
val bin_size_t :
edge Bin_prot.Size.sizer
val bin_write_t :
edge Bin_prot.Write.writer
val bin_writer_t :
edge Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
edge -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash :
t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable :
t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b,
(key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t ->
key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update :
'b t -> key -> f:('b option -> 'b) -> unit
val add_multi :
'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi :
'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf :
'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t ->
f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) ->
if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key ->
'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace :
'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal :
'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check ->
'b t Base__.Validate.check
val incr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int ->
?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> key
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t :
key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t :
key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig
val t_of_sexp : Sexplib.Sexp.t -> elt
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t :
elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = edge
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map :
'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> edge -> Core_kernel__.Import.bool
val lookup :
'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> edge -> 'a
val enqueue :
'a t ->
edge -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> edge -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val keys : 'a t -> edge Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (edge * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> edge * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> edge -> Core_kernel__.Import.unit
val replace :
'a t -> edge -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> edge -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:edge -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b ->
f:('b -> key:edge -> data:'a -> 'b) -> 'b
end
end
val empty : t
val nodes : t -> node Regular.Std.seq
val edges : t -> edge Regular.Std.seq
val is_directed : bool
val number_of_edges : t -> int
val number_of_nodes : t -> int
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator :
(t, comparator_witness) Base__.Comparator.comparator
val validate_lbound :
min:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_ubound :
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
val validate_bound :
min:t Base__.Maybe_bound.t ->
max:t Base__.Maybe_bound.t -> t Base__.Validate.check
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
end
module Map :
sig
module Key :
sig
type t = Edge.graph
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update :
'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t ->
data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partitioni_tf :
'a t ->
f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf :
'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check ->
'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(K : sig
val t_of_sexp : Sexplib.Sexp.t -> Key.t
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__017_) ->
Sexplib.Sexp.t -> 'v_x__017_ t
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, comparator_witness)
Core_kernel__.Core_map_intf.Map.t
val compare :
('a -> 'a -> Core_kernel__.Import.int) ->
'a t -> 'a t -> Core_kernel__.Import.int
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Base__.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Base__.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Key.t * 'a) -> 'a t
val of_iteri :
iteri:(f:(key:Key.t -> data:'v -> unit) -> unit) ->
[ `Duplicate_key of Key.t | `Ok of 'v t ]
val of_tree : 'a Tree.t -> 'a t
val of_hashtbl_exn :
(Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
val gen :
Key.t Core_kernel__.Quickcheck.Generator.t ->
'a Core_kernel__.Quickcheck.Generator.t ->
'a t Core_kernel__.Quickcheck.Generator.t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val remove_multi : 'a list t -> Key.t -> 'a list t
val change :
'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
val iter : 'a t -> f:('a -> unit) -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold2 :
'a t ->
'b t ->
init:'c ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c -> 'c) ->
'c
val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
val filter : 'a t -> f:('a -> bool) -> 'a t
val filteri :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val partition_mapi :
'a t ->
f:(key:Key.t -> data:'a -> [ `Fst of 'b | `Snd of 'c ]) ->
'b t * 'c t
val partition_map :
'a t ->
f:('a -> [ `Fst of 'b | `Snd of 'c ]) -> 'b t * 'c t
val partitioni_tf :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t * 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist :
?key_order:[ `Decreasing | `Increasing ] ->
'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Base__.Validate.check -> 'a t Base__.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t, 'a)
Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
Base__.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val for_alli :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val existsi :
'a t -> f:(key:Key.t -> data:'a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val counti :
'a t -> f:(key:Key.t -> data:'a -> bool) -> int
val split :
'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
val append :
lower_part:'a t ->
upper_part:'a t ->
[ `Ok of 'a t | `Overlapping_key_ranges ]
val subrange :
'a t ->
lower_bound:Key.t Base__.Maybe_bound.t ->
upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val closest_key :
'a t ->
[ `Greater_or_equal_to
| `Greater_than
| `Less_or_equal_to
| `Less_than ] -> Key.t -> (Key.t * 'a) option
val nth : 'a t -> int -> (Key.t * 'a) option
val nth_exn : 'a t -> int -> Key.t * 'a
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?order:[ `Decreasing_key | `Increasing_key ] ->
?keys_greater_or_equal_to:Key.t ->
?keys_less_or_equal_to:Key.t ->
'a t -> (Key.t * 'a) Base__.Sequence.t
val obs :
Key.t Core_kernel__.Quickcheck.Observer.t ->
'v Core_kernel__.Quickcheck.Observer.t ->
'v t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Key.t Core_kernel__.Quickcheck.Shrinker.t ->
'v Core_kernel__.Quickcheck.Shrinker.t ->
'v t Core_kernel__.Quickcheck.Shrinker.t
module Provide_of_sexp :
functor
(Key : sig
val t_of_sexp : Sexplib.Sexp.t -> Key.t
end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__018_) ->
Sexplib.Sexp.t -> 'v_x__018_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : Key.t Bin_prot.Type_class.t
val bin_read_t : Key.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Key.t)
Bin_prot.Read.reader
val bin_reader_t :
Key.t Bin_prot.Type_class.reader
val bin_size_t : Key.t Bin_prot.Size.sizer
val bin_write_t :
Key.t Bin_prot.Write.writer
val bin_writer_t :
Key.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Provide_hash :
functor
(Key : sig
val hash_fold_t :
Base__.Hash.state ->
Key.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
(Ppx_hash_lib.Std.Hash.state ->
'a -> Ppx_hash_lib.Std.Hash.state) ->
Ppx_hash_lib.Std.Hash.state ->
'a t -> Ppx_hash_lib.Std.Hash.state
end
val t_of_sexp :
(Base__.Sexplib.Sexp.t -> 'a) ->
Base__.Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Base__.Sexplib.Sexp.t) ->
'a t -> Base__.Sexplib.Sexp.t
end
module Set :
sig
module Elt :
sig
type t = Edge.graph
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
type comparator_witness = Map.Key.comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel__.Comparator.comparator
end
module Tree :
sig
type t =
(Elt.t, comparator_witness)
Core_kernel__.Core_set_intf.Tree.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map :
t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> Elt.t
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
type t = (Elt.t, comparator_witness) Base.Set.t
val compare : t -> t -> Core_kernel__.Import.int
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val fold_result :
t ->
init:'accum ->
f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val is_subset : t -> of_:t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
('b, 'stop)
Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val nth : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
val merge_to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t ->
t ->
(Elt.t, Elt.t)
Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
Base__.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, comparator_witness)
Core_kernel__.Core_set_intf.Map.t
val obs :
Elt.t Core_kernel__.Quickcheck.Observer.t ->
t Core_kernel__.Quickcheck.Observer.t
val shrinker :
Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
t Core_kernel__.Quickcheck.Shrinker.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val of_increasing_iterator_unchecked :
len:int -> f:(int -> Elt.t) -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Base.Set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Base.Set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
val of_hashtbl_keys :
(Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
val of_map_keys :
(Elt.t, 'a, comparator_witness)
Core_kernel__.Core_set_intf.Map.t -> t
val gen :
Elt.t Core_kernel__.Quickcheck.Generator.t ->
t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp :
functor
(Elt : sig
val t_of_sexp : Sexplib.Sexp.t -> Elt.t
end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(Elt : sig
val bin_t : Elt.t Bin_prot.Type_class.t
val bin_read_t : Elt.t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> Elt.t)
Bin_prot.Read.reader
val bin_reader_t :
Elt.t Bin_prot.Type_class.reader
val bin_size_t : Elt.t Bin_prot.Size.sizer
val bin_write_t :
Elt.t Bin_prot.Write.writer
val bin_writer_t :
Elt.t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(int -> t) Bin_prot.Read.reader
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Provide_hash :
functor
(Elt : sig
val hash_fold_t :
Base__.Hash.state ->
Elt.t -> Base__.Hash.state
end) ->
sig
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
end
val t_of_sexp : Base__.Sexplib.Sexp.t -> t
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
end
val hash : t -> Core_kernel__.Import.int
val compare : t -> t -> Core_kernel__.Import.int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
type 'b t = (key, 'b) hashtbl
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel__.Core_hashtbl_intf.Hashable.t
val invariant :
'a Base__.Invariant_intf.inv ->
'a t Base__.Invariant_intf.inv
val create :
(key, 'b, unit -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_key of key | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
(key, 'b,
(key * 'b) list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
(key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
(key, 'b, (key * 'b) list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
(key, 'b list, (key * 'b) list -> 'b list t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'b t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
(key, 'r,
get_key:('r -> key) ->
'r list ->
[ `Duplicate_keys of key list | `Ok of 'r t ])
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_or_error :
(key, 'r,
get_key:('r -> key) ->
'r list -> 'r t Base__.Or_error.t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
(key, 'r, get_key:('r -> key) -> 'r list -> 'r t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val group :
(key, 'b,
get_key:('r -> key) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> 'b t)
Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : 'a t -> key -> Base__.Sexp.t
val clear : 'a t -> unit
val copy : 'b t -> 'b t
val fold :
'b t ->
init:'c -> f:(key:key -> data:'b -> 'c -> 'c) -> 'c
val iter_keys : 'a t -> f:(key -> unit) -> unit
val iter : 'b t -> f:('b -> unit) -> unit
val iteri :
'b t -> f:(key:key -> data:'b -> unit) -> unit
val iter_vals : 'b t -> f:('b -> unit) -> unit
val existsi :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val exists : 'b t -> f:('b -> bool) -> bool
val for_alli :
'b t -> f:(key:key -> data:'b -> bool) -> bool
val for_all : 'b t -> f:('b -> bool) -> bool
val counti :
'b t -> f:(key:key -> data:'b -> bool) -> int
val count : 'b t -> f:('b -> bool) -> int
val length : 'a t -> int
val is_empty : 'a t -> bool
val mem : 'a t -> key -> bool
val remove : 'a t -> key -> unit
val replace : 'b t -> key:key -> data:'b -> unit
val set : 'b t -> key:key -> data:'b -> unit
val add :
'b t -> key:key -> data:'b -> [ `Duplicate | `Ok ]
val add_or_error :
'b t -> key:key -> data:'b -> unit Base__.Or_error.t
val add_exn : 'b t -> key:key -> data:'b -> unit
val change :
'b t -> key -> f:('b option -> 'b option) -> unit
val update : 'b t -> key -> f:('b option -> 'b) -> unit
val add_multi : 'b list t -> key:key -> data:'b -> unit
val remove_multi : 'a list t -> key -> unit
val map : 'b t -> f:('b -> 'c) -> 'c t
val mapi : 'b t -> f:(key:key -> data:'b -> 'c) -> 'c t
val filter_map : 'b t -> f:('b -> 'c option) -> 'c t
val filter_mapi :
'b t -> f:(key:key -> data:'b -> 'c option) -> 'c t
val filter_keys : 'b t -> f:(key -> bool) -> 'b t
val filter : 'b t -> f:('b -> bool) -> 'b t
val filteri :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t
val partition_map :
'b t ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> 'c t * 'd t
val partition_mapi :
'b t ->
f:(key:key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
'c t * 'd t
val partition_tf : 'b t -> f:('b -> bool) -> 'b t * 'b t
val partitioni_tf :
'b t -> f:(key:key -> data:'b -> bool) -> 'b t * 'b t
val find_or_add :
'b t -> key -> default:(unit -> 'b) -> 'b
val find : 'b t -> key -> 'b option
val find_exn : 'b t -> key -> 'b
val find_and_call :
'b t ->
key ->
if_found:('b -> 'c) -> if_not_found:(key -> 'c) -> 'c
val find_and_remove : 'b t -> key -> 'b option
val merge :
'a t ->
'b t ->
f:(key:key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
type 'a merge_into_action = Remove | Set_to of 'a
val merge_into :
src:'a t ->
dst:'b t ->
f:(key:key -> 'a -> 'b option -> 'b merge_into_action) ->
unit
val keys : 'a t -> key list
val data : 'b t -> 'b list
val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
val filter_inplace : 'b t -> f:('b -> bool) -> unit
val filteri_inplace :
'b t -> f:(key:key -> data:'b -> bool) -> unit
val map_inplace : 'b t -> f:('b -> 'b) -> unit
val mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_map_inplace :
'b t -> f:('b -> 'b option) -> unit
val filter_mapi_inplace :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val replace_all : 'b t -> f:('b -> 'b) -> unit
val replace_alli :
'b t -> f:(key:key -> data:'b -> 'b) -> unit
val filter_replace_all :
'b t -> f:('b -> 'b option) -> unit
val filter_replace_alli :
'b t -> f:(key:key -> data:'b -> 'b option) -> unit
val equal : 'b t -> 'b t -> ('b -> 'b -> bool) -> bool
val similar :
'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : 'b t -> (key * 'b) list
val validate :
name:(key -> string) ->
'b Base__.Validate.check -> 'b t Base__.Validate.check
val incr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
val decr :
?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
module Provide_of_sexp :
functor
(Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end) ->
sig
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__001_) ->
Sexplib.Sexp.t -> 'v_x__001_ t
end
module Provide_bin_io :
functor
(Key : sig
val bin_t : key Bin_prot.Type_class.t
val bin_read_t : key Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> key)
Bin_prot.Read.reader
val bin_reader_t :
key Bin_prot.Type_class.reader
val bin_size_t : key Bin_prot.Size.sizer
val bin_write_t : key Bin_prot.Write.writer
val bin_writer_t :
key Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t :
'a Bin_prot.Type_class.t ->
'a t Bin_prot.Type_class.t
val bin_read_t :
'a Bin_prot.Read.reader ->
'a t Bin_prot.Read.reader
val __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Core_kernel__.Import.int -> 'a t)
Bin_prot.Read.reader
val bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.reader
val bin_size_t :
'a Bin_prot.Size.sizer ->
'a t Bin_prot.Size.sizer
val bin_write_t :
'a Bin_prot.Write.writer ->
'a t Bin_prot.Write.writer
val bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writer
val bin_shape_t :
Bin_prot.Shape.t -> Bin_prot.Shape.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'v_x__002_) ->
Sexplib.Sexp.t -> 'v_x__002_ t
end
module Hash_set :
sig
type elt = t
type t = elt Core_kernel__.Hash_set.t
val sexp_of_t : t -> Sexplib.Sexp.t
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
val of_list :
('a, elt list -> t)
Core_kernel__.Hash_set_intf.create_options_without_hashable
module Provide_of_sexp :
functor
(X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end) ->
sig val t_of_sexp : Sexplib.Sexp.t -> t end
module Provide_bin_io :
functor
(X : sig
val bin_t : elt Bin_prot.Type_class.t
val bin_read_t : elt Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> elt)
Bin_prot.Read.reader
val bin_reader_t :
elt Bin_prot.Type_class.reader
val bin_size_t : elt Bin_prot.Size.sizer
val bin_write_t : elt Bin_prot.Write.writer
val bin_writer_t :
elt Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end) ->
sig
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ :
(Core_kernel__.Import.int -> t)
Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
end
val t_of_sexp : Sexplib.Sexp.t -> t
end
module Hash_queue :
sig
module Key :
sig
type t = Hash_set.elt
val sexp_of_t : t -> Base__.Sexplib.Sexp.t
val compare : t -> t -> int
val hash : t -> int
end
type 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val fold_result :
'a t ->
init:'accum ->
f:('accum -> 'a -> ('accum, 'e) Base__.Result.t) ->
('accum, 'e) Base__.Result.t
val fold_until :
'a t ->
init:'accum ->
f:('accum ->
'a ->
('accum, 'stop)
Base.Container_intf.Continue_or_stop.t) ->
('accum, 'stop)
Base.Container_intf.Finished_or_stopped_early.t
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Base__.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> Core_kernel__.Import.unit
val create :
?growth_allowed:Core_kernel__.Import.bool ->
?size:Core_kernel__.Import.int ->
Core_kernel__.Import.unit -> 'a t
val clear : 'a t -> Core_kernel__.Import.unit
val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
val lookup :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val lookup_and_move_to_back :
'a t -> Key.t -> 'a Core_kernel__.Import.option
val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
val first : 'a t -> 'a Core_kernel__.Import.option
val first_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val keys : 'a t -> Key.t Core_kernel__.Import.list
val dequeue : 'a t -> 'a Core_kernel__.Import.option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key :
'a t -> (Key.t * 'a) Core_kernel__.Import.option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all :
'a t ->
f:('a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn :
'a t -> Key.t -> Core_kernel__.Import.unit
val replace :
'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn :
'a t -> Key.t -> 'a -> Core_kernel__.Import.unit
val iteri :
'a t ->
f:(key:Key.t -> data:'a -> Core_kernel__.Import.unit) ->
Core_kernel__.Import.unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
val pp_seq :
Format.formatter -> t Core_kernel.Std.Sequence.t -> unit
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
end
val fixpoint :
(module Graphlib.Std.Graph with type node = 'n and type t = 'c) ->
?steps:int ->
?start:'n ->
?rev:bool ->
?step:(int -> 'n -> 'd -> 'd -> 'd) ->
init:('n, 'd) Graphlib.Std.Solution.t ->
equal:('d -> 'd -> bool) ->
merge:('d -> 'd -> 'd) ->
f:('n -> 'd -> 'd) -> 'c -> ('n, 'd) Graphlib.Std.Solution.t
type scheme
type 'a symbolizer = 'a -> string
val create_scheme :
next:(string -> string) -> string -> Graphlib.Std.Graphlib.scheme
val symbols : Graphlib.Std.Graphlib.scheme
val numbers : Graphlib.Std.Graphlib.scheme
val nothing : Graphlib.Std.Graphlib.scheme
val by_given_order :
Graphlib.Std.Graphlib.scheme ->
('a -> 'a -> int) ->
'a Core_kernel.Std.Sequence.t ->
'a Graphlib.Std.Graphlib.symbolizer
val by_natural_order :
Graphlib.Std.Graphlib.scheme ->
('a -> 'a -> int) ->
'a Core_kernel.Std.Sequence.t ->
'a Graphlib.Std.Graphlib.symbolizer
module Dot :
sig
val pp_graph :
?name:string ->
?attrs:string list ->
?string_of_node:'n Graphlib.Std.Graphlib.symbolizer ->
?node_label:'n Graphlib.Std.Graphlib.symbolizer ->
?edge_label:'e Graphlib.Std.Graphlib.symbolizer ->
nodes_of_edge:('e -> 'n * 'n) ->
nodes:'n Core_kernel.Std.Sequence.t ->
edges:'e Core_kernel.Std.Sequence.t ->
Format.formatter -> unit
end
end
end
end